Update app.js

app.js

@@ -8,7 +8,7 @@
  *      matching the depth the AI produces (scope_depth 2-3, EMERGES,
  *      CONTRADICT, CONSERVES, STEP/CANDIDATE where applicable)
  *   2. POST-PROCESSING NORMALIZER: every sample's c_values are mapped
- *      to [0,1] relative to declared bounds before saving. No more
+ *      to[0,1] relative to declared bounds before saving. No more
  *      raw voltages, payoffs, or angles in c_values.
  *   3. VALIDATION: catches string c_values, missing VARS prefix,
  *      mask length mismatch, non-finite b_raw — all logged and rejected.
@@ -31,6 +31,7 @@
  */
 
 import express      from "express";
+import cors         from "cors";
 import { randomUUID } from "crypto";
 import fs           from "fs";
 import path         from "path";
@@ -42,14 +43,14 @@ import {
 // ── CONFIG ────────────────────────────────────────────────────────────────────
 const PORT             = parseInt(process.env.PORT          || "7860");
 const AWS_REGION       = process.env.AWS_REGION             || "us-east-1";
-const BEDROCK_MODEL =  "arn:aws:bedrock:us-east-1:106774395747:inference-profile/global.anthropic.claude-sonnet-4-6";
- //"arn:aws:bedrock:us-east-1:106774395747:inference-profile/global.anthropic.claude-haiku-4-5-20251001-v1:0";
+const BEDROCK_MODEL    = "arn:aws:bedrock:us-east-1:106774395747:inference-profile/global.anthropic.claude-sonnet-4-6";
        
 const DATASET_PATH     = process.env.DATASET_PATH           || "axl_dataset.json";
 const DEFAULT_RPS      = parseFloat(process.env.DEFAULT_RPS || "3");
 const MAX_RPS          = parseFloat(process.env.MAX_RPS     || "8");
 const SAMPLES_PER_CALL = parseInt(process.env.SAMPLES_PER_CALL || "20");
 const SCALE_K          = 30.0;
+const LATENT_D_MAX     = 8; // Added for correct mask padding
 
 // ── LOGGING ───────────────────────────────────────────────────────────────────
 const ts  = () => new Date().toISOString().slice(11, 23);
@@ -76,9 +77,11 @@ const randchoice = (arr) => arr[Math.floor(Math.random() * arr.length)];
  */
 function normalizeSample(s) {
     const parsed = parseVarsBounds(s.vars_text, s.n_vars);
-    const raw    = s.c_values;
-
-    if (!Array.isArray(raw) || raw.length !== s.n_vars) return null;
+    
+    if (!Array.isArray(s.c_values) || s.c_values.length < s.n_vars) return null;
+    
+    // Tolerate if AI appended extra zeros by slicing to exact n_vars
+    const raw = s.c_values.slice(0, s.n_vars);
 
     const normalized = raw.map((v, i) => {
         if (typeof v !== "number" || !isFinite(v)) return null;
@@ -89,8 +92,8 @@ function normalizeSample(s) {
 
     if (normalized.includes(null)) return null;
 
-    // Rebuild mask to correct length (always LATENT_D_MAX inferred from data)
-    const mask = Array(s.n_vars).fill(1);
+    // Pad mask to the global LATENT_D_MAX requirement
+    const mask =[...Array(s.n_vars).fill(1), ...Array(Math.max(0, LATENT_D_MAX - s.n_vars)).fill(0)];
 
     return {
         ...s,
@@ -102,14 +105,14 @@ function normalizeSample(s) {
 }
 
 function parseVarsBounds(varsText, nVars) {
-    // Returns [[lo,hi], ...] for each variable
+    // Returns [[lo,hi], ...] for each variable. [FIX]: Now tolerates commas
     const bounds = [];
-    const re = /IN\s*[\[({]?\s*(-?[\d.e+\-]+)\s+(-?[\d.e+\-]+)\s*[\])}]?/gi;
+    const re = /IN\s*[\[({]?\s*(-?[\d.e+\-]+)[\s,]+(-?[\d.e+\-]+)\s*[\])}]?/gi;
     let m;
     while ((m = re.exec(varsText)) !== null) {
         bounds.push([parseFloat(m[1]), parseFloat(m[2])]);
     }
-    // Pad with [0,1] if fewer bounds than vars
+    // Pad with[0,1] if fewer bounds than vars
     while (bounds.length < nVars) bounds.push([0, 1]);
     return bounds;
 }
@@ -122,7 +125,7 @@ function ensureVarsPrefix(vt) {
 
 // ── VALIDATION ────────────────────────────────────────────────────────────────
 function validateSample(s) {
-    const required = ["domain","sense","n_vars","vars_text","expr_text",
+    const required =["domain","sense","n_vars","vars_text","expr_text",
                       "sense_text","b_raw","c_values","mask"];
     for (const f of required) {
         if (s[f] === undefined || s[f] === null) {
@@ -131,7 +134,7 @@ function validateSample(s) {
         }
     }
     if (!Array.isArray(s.c_values))              { log(`Reject: c_values not array`,      "WARN"); return false; }
-    if (s.c_values.length !== s.n_vars)          { log(`Reject: c_values len mismatch`,   "WARN"); return false; }
+    if (s.c_values.length < s.n_vars)            { log(`Reject: c_values len mismatch`,   "WARN"); return false; }
     if (s.c_values.some(v => typeof v !== "number" || !isFinite(v))) {
         log(`Reject: non-numeric c_values in ${s.domain}`, "WARN"); return false;
     }
@@ -152,7 +155,7 @@ function validateSample(s) {
 // ── PHYSICS ───────────────────────────────────────────────────────────────────
 function synthPhysicsSamples(n) {
     const samples = [];
-    const templates = [
+    const templates =[
         {
             name: "Kinetic Energy",
             fn: (c) => 0.5 * (c[0]) * (c[1])**2,
@@ -218,7 +221,7 @@ function synthPhysicsSamples(n) {
                 `  ASSUME ${t.conserves}`,
                 `END SCOPE`,
                 ``,
-                `SCOPE ${t.name.toLowerCase().replace(/ /g,"_")} [level: 1]`,
+                `SCOPE ${t.name.toLowerCase().replace(/ /g,"_")}[level: 1]`,
                 `  ASSUME physics_primitives SCOPE HOLDS`,
                 ``,
                 `  ENTITY physical_system`,
@@ -255,7 +258,7 @@ function synthPhysicsSamples(n) {
                 b_raw: fmt(bRaw), b_norm: fmt(safeNorm(bRaw), 8),
                 c_values: cRaw.map(v => fmt(v)),
                 mask: Array(nVars).fill(1),
-                candidates: [], step_count: 0, axl_source: axl,
+                candidates:[], step_count: 0, axl_source: axl,
                 metadata: {
                     description: `${t.name} constraint inversion: ${t.formula} = ${bRaw.toFixed(4)}`,
                     units: t.units, difficulty: "medium",
@@ -269,7 +272,7 @@ function synthPhysicsSamples(n) {
 
 // ── FINANCE ───────────────────────────────────────────────────────────────────
 function synthFinanceSamples(n) {
-    const samples = [];
+    const samples =[];
     for (let i = 0; i < n; i++) {
         const kind = randchoice(["compound","loan","portfolio_variance","sharpe"]);
         try {
@@ -292,9 +295,9 @@ function synthFinanceSamples(n) {
                 subdomain = "loan_payment";
                 desc = `Monthly payment: ${bRaw.toFixed(2)}`;
             } else if (kind === "portfolio_variance") {
-                const w = [rnd(0,1), rnd(0,1), rnd(0,1)];
+                const w =[rnd(0,1), rnd(0,1), rnd(0,1)];
                 const s = w.reduce((a,b)=>a+b,0); w[0]/=s; w[1]/=s; w[2]/=s;
-                const sig = [rnd(0.05,0.3), rnd(0.02,0.15), rnd(0.01,0.08)];
+                const sig =[rnd(0.05,0.3), rnd(0.02,0.15), rnd(0.01,0.08)];
                 const rho01 = rnd(-0.3,0.5), rho02 = rnd(-0.2,0.4), rho12 = rnd(-0.1,0.3);
                 bRaw = w[0]**2*sig[0]**2 + w[1]**2*sig[1]**2 + w[2]**2*sig[2]**2
                      + 2*w[0]*w[1]*rho01*sig[0]*sig[1]
@@ -306,9 +309,9 @@ function synthFinanceSamples(n) {
                 subdomain = "portfolio_variance";
                 desc = `Minimum variance portfolio: variance=${bRaw.toFixed(5)}`;
             } else {
-                const ret = [rnd(0.05,0.25), rnd(0.02,0.12), rnd(0.01,0.05)];
-                const risk = [rnd(0.1,0.4), rnd(0.05,0.2), rnd(0.01,0.05)];
-                const w = [rnd(0.2,0.6), rnd(0.1,0.4), rnd(0.05,0.3)];
+                const ret =[rnd(0.05,0.25), rnd(0.02,0.12), rnd(0.01,0.05)];
+                const risk =[rnd(0.1,0.4), rnd(0.05,0.2), rnd(0.01,0.05)];
+                const w =[rnd(0.2,0.6), rnd(0.1,0.4), rnd(0.05,0.3)];
                 const s = w.reduce((a,b)=>a+b,0); w[0]/=s; w[1]/=s; w[2]/=s;
                 const portRet = w.reduce((a,v,j)=>a+v*ret[j],0);
                 const portRisk = Math.sqrt(w.reduce((a,v,j)=>a+v**2*risk[j]**2,0));
@@ -368,7 +371,7 @@ function synthFinanceSamples(n) {
                 b_raw: fmt(bRaw), b_norm: fmt(safeNorm(bRaw), 8),
                 c_values: cRaw.map(v => fmt(v)),
                 mask: Array(nVars).fill(1),
-                candidates: [], step_count: 0, axl_source: axl,
+                candidates:[], step_count: 0, axl_source: axl,
                 metadata: {
                     description: desc, units: "currency",
                     difficulty: "medium", scope_depth: 2,
@@ -382,7 +385,7 @@ function synthFinanceSamples(n) {
 
 // ── CRYPTOGRAPHY (full depth — from synthCryptoSamples.js) ───────────────────
 function synthXorSamples(n) {
-    const samples = [];
+    const samples =[];
     for (let i = 0; i < n; i++) {
         const key = randint(0,255), plain = randint(0,255);
         const cipher = key ^ plain;
@@ -399,7 +402,7 @@ function synthXorSamples(n) {
         ].join("\n")).join("\n");
 
         const axl = [
-            `SCOPE xor_bit_level [level: 0]`,
+            `SCOPE xor_bit_level[level: 0]`,
             `  ASSUME bit EXISTS`,
             `  ASSUME bit DISCRETE VALUES {0, 1}`,
             `  TRANSFORM xor_gate`,
@@ -431,7 +434,7 @@ function synthXorSamples(n) {
             `    DERIVES raw FROM {key_byte.raw, plain_byte.raw} BY xor_byte_transform`,
             `  END ENTITY`,
             `  TRANSFORM xor_byte_transform`,
-            `    INPUT  {key: INTEGER BOUND [0,255], plain: INTEGER BOUND [0,255]}`,
+            `    INPUT  {key: INTEGER BOUND[0,255], plain: INTEGER BOUND [0,255]}`,
             `    OUTPUT {cipher: INTEGER BOUND [0,255]}`,
             `    CONSERVES nothing`,
             `    CHANGES cipher`,
@@ -450,12 +453,12 @@ function synthXorSamples(n) {
         samples.push({
             id: randomUUID(), domain: "cryptography", subdomain: "xor_byte",
             sense: "EQUAL", n_vars: 1,
-            vars_text: "VARS c0 IN [0 1]",
+            vars_text: "VARS c0 IN[0 255]",
             expr_text: `EXPR XOR plain=${plain} cipher=${cipher} key=UNKNOWN`,
             sense_text: "SENSE EQUAL",
             b_raw: fmt(cipher), b_norm: fmt(safeNorm(cipher), 8),
-            c_values: [fmt(key/255.0)],
-            mask: [1], candidates: [], step_count: 0, axl_source: axl,
+            c_values: [key],
+            mask: [1], candidates:[], step_count: 0, axl_source: axl,
             metadata: {
                 description: `XOR byte: plain=${plain} key=${key} → cipher=${cipher}`,
                 units: "character_code", difficulty: "medium",
@@ -469,7 +472,7 @@ function synthXorSamples(n) {
 }
 
 function synthCaesarSamples(n) {
-    const samples = [];
+    const samples =[];
     for (let i = 0; i < n; i++) {
         const msgLen = randint(1,4);
         const shift  = randint(0,25);
@@ -491,7 +494,7 @@ function synthCaesarSamples(n) {
             `  ASSUME modular_arithmetic HOLDS`,
             `  ENTITY alphabet`,
             `    FIELD size: INTEGER EQUALS 26`,
-            `    BOUND any_char WITHIN [0, 25]`,
+            `    BOUND any_char WITHIN[0, 25]`,
             `  END ENTITY`,
             `  TRANSFORM modular_add`,
             `    INPUT  {a: INTEGER, b: INTEGER, mod: INTEGER}`,
@@ -521,7 +524,7 @@ function synthCaesarSamples(n) {
             `SCOPE caesar_message [level: 2]`,
             `  ASSUME caesar_char SCOPE HOLDS`,
             `  ENTITY message`,
-            `    FIELD plaintext:  VECTOR OF INTEGER EQUALS [${plains.join(", ")}]`,
+            `    FIELD plaintext:  VECTOR OF INTEGER EQUALS[${plains.join(", ")}]`,
             `    FIELD ciphertext: VECTOR OF INTEGER`,
             `    FIELD length:     INTEGER EQUALS ${msgLen}`,
             `    DERIVES ciphertext FROM {plaintext, shift_key.raw} BY caesar_transform APPLIED_TO_EACH`,
@@ -540,12 +543,12 @@ function synthCaesarSamples(n) {
         samples.push({
             id: randomUUID(), domain: "cryptography", subdomain: "caesar",
             sense: "EQUAL", n_vars: 1,
-            vars_text: "VARS c0 IN [0 1]",
+            vars_text: "VARS c0 IN[0 25]",
             expr_text: `EXPR CAESAR plains=[${plains}] ciphers=[${ciphers}] shift=UNKNOWN`,
             sense_text: "SENSE EQUAL",
             b_raw: fmt(bRaw), b_norm: fmt(safeNorm(bRaw), 8),
-            c_values: [fmt(shift/25.0)],
-            mask: [1], candidates: [], step_count: 0, axl_source: axl,
+            c_values: [shift],
+            mask: [1], candidates:[], step_count: 0, axl_source: axl,
             metadata: {
                 description: `Caesar: shift=${shift} plains=[${plains}] → [${ciphers}]`,
                 units: "character_code_sum",
@@ -558,7 +561,7 @@ function synthCaesarSamples(n) {
 }
 
 function synthVigenereSamples(n) {
-    const samples = [];
+    const samples =[];
     for (let i = 0; i < n; i++) {
         const keyLen = randint(2,5);
         const key    = Array.from({length:keyLen},()=>randint(0,25));
@@ -570,7 +573,7 @@ function synthVigenereSamples(n) {
             `  ENTITY position_${idx}`,
             `    FIELD plaintext:  INTEGER EQUALS ${p}`,
             `    FIELD key_char:   INTEGER BOUND [0, 25]`,
-            `    FIELD ciphertext: INTEGER BOUND [0, 25]`,
+            `    FIELD ciphertext: INTEGER BOUND[0, 25]`,
             `    DERIVES ciphertext FROM {plaintext, key_char} BY modular_add_26`,
             `  END ENTITY`,
         ].join("\n")).join("\n");
@@ -599,7 +602,7 @@ function synthVigenereSamples(n) {
             `  ASSUME vigenere_position SCOPE HOLDS`,
             `  ENTITY key_vector`,
             `    FIELD chars:      VECTOR OF INTEGER BOUND [0, 25]`,
-            `    FIELD normalised: VECTOR OF REAL    BOUND [0, 1]`,
+            `    FIELD normalised: VECTOR OF REAL    BOUND[0, 1]`,
             `    DERIVES normalised FROM chars BY divide_each_by_25`,
             `  END ENTITY`,
             `  ENTITY plaintext_vector`,
@@ -610,7 +613,7 @@ function synthVigenereSamples(n) {
             `    DERIVES chars FROM {plaintext_vector.chars, key_vector.chars}`,
             `      BY modular_add_26 APPLIED_PAIRWISE`,
             `  END ENTITY`,
-            `  OBSERVE ciphertext_vector.chars EQUALS [${cipher.join(", ")}]`,
+            `  OBSERVE ciphertext_vector.chars EQUALS[${cipher.join(", ")}]`,
             `  OBSERVE SUM(ciphertext_vector.chars) EQUALS ${bRaw}`,
             `  UNKNOWN key_vector.normalised: VECTOR OF REAL BOUND [0, 1]`,
             `  COLLAPSE vigenere_composition`,
@@ -621,7 +624,7 @@ function synthVigenereSamples(n) {
             `END SCOPE`,
         ].join("\n");
 
-        const varsText = `VARS ${Array.from({length:keyLen},(_,j)=>`c${j} IN [0 1]`).join(" ")}`;
+        const varsText = `VARS ${Array.from({length:keyLen},(_,j)=>`c${j} IN [0 25]`).join(" ")}`;
         samples.push({
             id: randomUUID(), domain: "cryptography",
             subdomain: `vigenere_${keyLen}char`,
@@ -629,9 +632,9 @@ function synthVigenereSamples(n) {
             expr_text: `EXPR VIGENERE keyLen=${keyLen} plains=[${plain}] ciphers=[${cipher}] key=UNKNOWN`,
             sense_text: "SENSE EQUAL",
             b_raw: fmt(bRaw), b_norm: fmt(safeNorm(bRaw), 8),
-            c_values: key.map(k=>fmt(k/25.0)),
+            c_values: key,
             mask: Array(keyLen).fill(1),
-            candidates: [], step_count: 0, axl_source: axl,
+            candidates:[], step_count: 0, axl_source: axl,
             metadata: {
                 description: `Vigenère ${keyLen}-char key=[${key}]`,
                 units: "character_code_sum",
@@ -644,9 +647,9 @@ function synthVigenereSamples(n) {
 }
 
 function synthAffineSamples(n) {
-    const VALID_A   = [1,3,5,7,9,11,15,17,19,21,23,25];
+    const VALID_A   =[1,3,5,7,9,11,15,17,19,21,23,25];
     const INV_A_MAP = {1:1,3:9,5:21,7:15,9:3,11:19,15:7,17:23,19:11,21:5,23:17,25:25};
-    const samples   = [];
+    const samples   =[];
     for (let i = 0; i < n; i++) {
         const aIdx  = randint(0,11);
         const a     = VALID_A[aIdx];
@@ -657,7 +660,7 @@ function synthAffineSamples(n) {
         const verify = ((aInv*(cipher-b))%26+26)%26;
         if (verify !== p) continue;
 
-        const axl = [
+        const axl =[
             `SCOPE modular_arithmetic [level: 0]`,
             `  ASSUME integer EXISTS`,
             `  TRANSFORM modular_multiply_add`,
@@ -677,8 +680,8 @@ function synthAffineSamples(n) {
             `  ASSUME modular_arithmetic SCOPE HOLDS`,
             `  ENTITY affine_key`,
             `    FIELD a:      INTEGER DISCRETE VALUES {1,3,5,7,9,11,15,17,19,21,23,25}`,
-            `    FIELD b:      INTEGER BOUND [0, 25]`,
-            `    FIELD a_idx:  INTEGER BOUND [0, 11]`,
+            `    FIELD b:      INTEGER BOUND[0, 25]`,
+            `    FIELD a_idx:  INTEGER BOUND[0, 11]`,
             `    FIELD a_norm: REAL    BOUND [0, 1]`,
             `    FIELD b_norm: REAL    BOUND [0, 1]`,
             `    DERIVES a     FROM a_idx BY lookup_valid_a`,
@@ -687,16 +690,14 @@ function synthAffineSamples(n) {
             `    BOUND a COPRIME_TO 26`,
             `  END ENTITY`,
             `  ENTITY affine_transform_result`,
-            `    FIELD plaintext:  INTEGER BOUND [0, 25] EQUALS ${p}`,
+            `    FIELD plaintext:  INTEGER BOUND[0, 25] EQUALS ${p}`,
             `    FIELD ciphertext: INTEGER BOUND [0, 25]`,
             `    DERIVES ciphertext FROM {affine_key.a, plaintext, affine_key.b} BY modular_multiply_add`,
-            `    # f(${p}) = (${a} * ${p} + ${b}) mod 26 = ${cipher}`,
             `  END ENTITY`,
             `  ENTITY affine_inverse`,
             `    FIELD a_inv: INTEGER EQUALS ${aInv}`,
             `    FIELD recovery: INTEGER`,
             `    DERIVES recovery FROM {a_inv, ciphertext, b} BY modular_multiply_add`,
-            `    # a_inv*(cipher-b) mod 26 = ${p} ✓`,
             `  END ENTITY`,
             `  CONTRADICT invertible WITH non_coprime_a`,
             `    AT SCOPE affine_cipher`,
@@ -716,12 +717,12 @@ function synthAffineSamples(n) {
         samples.push({
             id: randomUUID(), domain: "cryptography", subdomain: "affine",
             sense: "EQUAL", n_vars: 2,
-            vars_text: "VARS c0 IN [0 1] c1 IN [0 1]",
+            vars_text: "VARS c0 IN [0 11] c1 IN[0 25]",
             expr_text: `EXPR AFFINE a=${a}(idx=${aIdx}) b=${b} plain=${p} cipher=${cipher}`,
             sense_text: "SENSE EQUAL",
             b_raw: fmt(cipher), b_norm: fmt(safeNorm(cipher), 8),
-            c_values: [fmt(aIdx/11.0), fmt(b/25.0)],
-            mask: [1,1], candidates: [], step_count: 0, axl_source: axl,
+            c_values: [aIdx, b],
+            mask: [1,1], candidates:[], step_count: 0, axl_source: axl,
             metadata: {
                 description: `Affine a=${a} b=${b} plain=${p} → cipher=${cipher}`,
                 units: "character_code", difficulty: "hard",
@@ -735,7 +736,7 @@ function synthAffineSamples(n) {
 
 // ── OPTIMIZATION (deep AXL, not just a label) ─────────────────────────────────
 function synthOptimizationSamples(n) {
-    const samples = [];
+    const samples =[];
     for (let i = 0; i < n; i++) {
         const sense  = randchoice(["MINIMIZE","MAXIMIZE"]);
         const nVars  = randint(2,6);
@@ -746,7 +747,7 @@ function synthOptimizationSamples(n) {
             const bRaw   = cVals.reduce((acc,v,j)=>acc+v*coeffs[j],0);
             const exprStr = coeffs.map((c,j)=>`${c.toFixed(3)}*c${j}`).join(" + ");
 
-            const axl = [
+            const axl =[
                 `SCOPE constraint_primitives [level: 0]`,
                 `  ASSUME variable EXISTS`,
                 `  ASSUME variable BOUND [0, 1]`,
@@ -793,13 +794,13 @@ function synthOptimizationSamples(n) {
                 id: randomUUID(), domain: "optimization",
                 subdomain: `linear_${sense.toLowerCase()}_${nVars}var`,
                 sense, n_vars: nVars,
-                vars_text: `VARS ${Array.from({length:nVars},(_,j)=>`c${j} IN [0 1]`).join(" ")}`,
+                vars_text: `VARS ${Array.from({length:nVars},(_,j)=>`c${j} IN[0 1]`).join(" ")}`,
                 expr_text: `EXPR ${exprStr}`,
                 sense_text: `SENSE ${sense}`,
                 b_raw: fmt(bRaw), b_norm: fmt(safeNorm(bRaw), 8),
                 c_values: cVals.map(v=>fmt(v)),
                 mask: Array(nVars).fill(1),
-                candidates: [], step_count: 0, axl_source: axl,
+                candidates:[], step_count: 0, axl_source: axl,
                 metadata: {
                     description: `Linear ${sense.toLowerCase()} over ${nVars} variables`,
                     units: "objective", difficulty: "easy",
@@ -824,7 +825,7 @@ const SYNTHETIC_GENERATORS = {
 
 // ── FOCUS TRACKER ─────────────────────────────────────────────────────────────
 const tracker = {
-    recent: [], counts: {}, total: 0,
+    recent:[], counts: {}, total: 0,
     record(domain) {
         this.recent.push(domain);
         if (this.recent.length > 100) this.recent.shift();
@@ -837,7 +838,7 @@ const tracker = {
 };
 
 // ── DATASET STATE ─────────────────────────────────────────────────────────────
-let dataset = [];
+let dataset =[];
 function loadDataset() {
     if (fs.existsSync(DATASET_PATH)) {
         dataset = JSON.parse(fs.readFileSync(DATASET_PATH,"utf8"));
@@ -852,7 +853,6 @@ function saveDataset() {
 // ── BEDROCK CLIENT ────────────────────────────────────────────────────────────
 const bedrock = new BedrockRuntimeClient({ region: AWS_REGION });
 
-// USER: replace this string with the full AXL spec text
 const AXL_SPEC = `
 # AXL — Abstraction Exchange Language
 ### A Constraint-First, Bidirectionally Navigable Abstraction Language
@@ -995,7 +995,7 @@ The system will work backwards from this to find what
 configuration of unknowns is consistent with it.
 
 OBSERVE <field | entity | state> EQUALS <value>
-OBSERVE <field> WITHIN [<min>, <max>]
+OBSERVE <field> WITHIN[<min>, <max>]
 OBSERVE <pattern> IN <output>
 
 ---
@@ -1184,7 +1184,7 @@ SCOPE quantum[level: 0]
   END ENTITY
 
   ENTITY gluon
-    FIELD charge: BOUND [0, 0] CONSERVES
+    FIELD charge: BOUND[0, 0] CONSERVES
     FIELD color: SYMBOLIC                      # carries color charge
     TENDS quark_binding MAX                    # gluons maximize binding
   END ENTITY
@@ -1223,7 +1223,7 @@ SCOPE hadron [level: 1]
 END SCOPE
 
 
-SCOPE nucleus [level: 2]
+SCOPE nucleus[level: 2]
 
   ASSUME hadron SCOPE HOLDS
 
@@ -1262,7 +1262,7 @@ SCOPE atom [level: 3]
   ASSUME nucleus SCOPE HOLDS
 
   ENTITY electron
-    FIELD charge: BOUND [-1, -1] CONSERVES
+    FIELD charge: BOUND[-1, -1] CONSERVES
     FIELD mass: BOUND[9.109e-31, 9.109e-31] CONSERVES
     FIELD spin: DISCRETE VALUES {-0.5, 0.5}
     FIELD orbital: DISCRETE VALUES {s, p, d, f}
@@ -1376,7 +1376,7 @@ SCOPE sha256_internals [level: 1]
 END SCOPE
 
 
-SCOPE block_header [level: 2]
+SCOPE block_header[level: 2]
 
   ASSUME sha256_internals SCOPE HOLDS
 
@@ -1386,7 +1386,7 @@ SCOPE block_header [level: 2]
     FIELD merkle_root: bit_array BOUND length EQUALS 256 # GIVEN, fixed
     FIELD timestamp: INTEGER                              # GIVEN, approximately fixed
     FIELD bits: INTEGER                                   # GIVEN, encodes target
-    FIELD nonce: INTEGER BOUND [0, 4294967295]           # UNKNOWN — 32 bits of freedom
+    FIELD nonce: INTEGER BOUND[0, 4294967295]           # UNKNOWN — 32 bits of freedom
   END ENTITY
 
   DERIVE target
@@ -1750,7 +1750,7 @@ STRICT REQUIREMENTS:
 3. b_raw must be a computed finite float matching the AXL program's logic.
 4. c_values must be in RAW domain units matching the declared bounds in vars_text.
    DO NOT pre-normalize to [0,1] — the pipeline does that. Example: if
-   vars_text says "VARS c0 IN [200 800]" then c_values should be like [650, 210].
+   vars_text says "VARS c0 IN [200 800]" then c_values should be like[650, 210].
 5. Every vars_text MUST start with the word VARS.
 6. Every sample must use a DIFFERENT domain or structural pattern.
 7. Vary: sense (EQUAL/MINIMIZE/MAXIMIZE/SELECT/TEND), n_vars (1-${maxVars}),
@@ -1769,14 +1769,14 @@ JSON SCHEMA (output array of these):
   "subdomain": "<specific topic>",
   "sense": "<EQUAL|MINIMIZE|MAXIMIZE|SELECT|TEND>",
   "n_vars": <integer>,
-  "vars_text": "VARS c0 IN [lo hi] c1 IN [lo hi] ...",
+  "vars_text": "VARS c0 IN[lo hi] c1 IN [lo hi] ...",
   "expr_text": "EXPR <description>",
   "sense_text": "SENSE <EQUAL|MINIMIZE|MAXIMIZE|SELECT|TEND>",
   "b_raw": <float>,
   "b_norm": <sign(b)*log(1+|b|)/30>,
-  "c_values": [<raw domain values matching bounds>],
+  "c_values":[<raw domain values matching bounds>],
   "mask": [1,1,...],
-  "candidates": [],
+  "candidates":[],
   "step_count": <integer>,
   "axl_source": "<full multi-scope AXL program as single string>",
   "metadata": {
@@ -1811,7 +1811,7 @@ async function callBedrock(prompt) {
     const raw  = JSON.parse(Buffer.from(res.body).toString("utf8"));
     const text = raw.content[0].text;
     log(`Bedrock call ${((Date.now()-t0)/1000).toFixed(1)}s — ${text.length} chars`);
-   const tokenUsage = res.usage ? (res.usage.inputTokens + res.usage.outputTokens) : 0;
+   const tokenUsage = raw.usage ? (raw.usage.input_tokens + raw.usage.output_tokens) : 0;
   console.log(tokenUsage)
   return text;
 }
@@ -1824,12 +1824,12 @@ function parseAIResponse(text) {
     if (t.endsWith("```")) t = t.slice(0,-3);
     t = t.trim();
     const start = t.indexOf("["), end = t.lastIndexOf("]");
-    if (start === -1 || end === -1) return [];
+    if (start === -1 || end === -1) return[];
     try {
         return JSON.parse(t.slice(start, end+1));
     } catch(e) {
         log(`JSON parse error: ${e.message} — attempting salvage`, "WARN");
-        const saved = [];
+        const saved =[];
         let depth = 0, buf = "", inObj = false;
         for (const ch of t.slice(start+1, end)) {
             if (ch === "{") { depth++; inObj = true; }
@@ -1849,6 +1849,7 @@ function parseAIResponse(text) {
 
 // ── EXPRESS APP ───────────────────────────────────────────────────────────────
 const app = express();
+app.use(cors());
 app.use(express.json());
 
 app.get("/status", (_, res) => res.json({
@@ -1862,14 +1863,14 @@ app.get("/status", (_, res) => res.json({
 app.get("/domains", (_, res) => res.json(tracker.stats()));
 
 app.post("/generate", async (req, res) => {
-    const n                  = parseInt(req.query.n   || "50");
-    const rps                = Math.min(parseFloat(req.query.rps || DEFAULT_RPS), MAX_RPS);
-    const syntheticFraction  = parseFloat(req.query.synthetic_fraction || "0.4");
-    const maxVars            = parseInt(req.query.max_vars || "20");
+    const n = parseInt(req.query.n ?? req.body.n ?? "50");
+    const rps = Math.min(parseFloat(req.query.rps ?? req.body.rps ?? DEFAULT_RPS.toString()), MAX_RPS);
+    const syntheticFraction = parseFloat(req.query.synthetic_fraction ?? req.body.synthetic_fraction ?? "0.4");
+    const maxVars = parseInt(req.query.max_vars ?? req.body.max_vars ?? "20");
 
     log(`Generation request: n=${n} rps=${rps} synthetic=${(syntheticFraction*100).toFixed(0)}%`, "HEAD");
 
-    const generated = [];
+    const generated =[];
     let errors = 0;
 
     // ── SYNTHETIC BATCH ──
@@ -1877,7 +1878,7 @@ app.post("/generate", async (req, res) => {
     if (nSynthetic > 0) {
         const gens    = Object.values(SYNTHETIC_GENERATORS);
         const perGen  = Math.max(1, Math.ceil(nSynthetic / gens.length));
-        for (const [name, genFn] of Object.entries(SYNTHETIC_GENERATORS)) {
+        for (const[name, genFn] of Object.entries(SYNTHETIC_GENERATORS)) {
             for (const raw of genFn(perGen)) {
                 if (!validateSample(raw)) { errors++; continue; }
                 const norm = normalizeSample(raw);
@@ -1948,7 +1949,7 @@ app.get("/dataset/download", (req, res) => {
 
 app.post("/dataset/clear", (_, res) => {
     const count = dataset.length;
-    dataset = [];
+    dataset =[];
     if (fs.existsSync(DATASET_PATH)) fs.unlinkSync(DATASET_PATH);
     log(`Cleared ${count} samples`, "OK");
     res.json({ cleared: count });
@@ -1962,12 +1963,9 @@ app.get("/dataset/sample", (req, res) => {
 
 // ── STARTUP ───────────────────────────────────────────────────────────────────
 loadDataset();
-app.listen(PORT, () => {
+app.listen(PORT, '0.0.0.0', () => {
     log(`AXL Dataset Server listening on :${PORT}`, "OK");
     log(`Model:   ${BEDROCK_MODEL}`);
     log(`Dataset: ${DATASET_PATH}`);
     log(`RPS:     ${DEFAULT_RPS} default / ${MAX_RPS} max`);
-    if (AXL_SPEC === "[PASTE_AXL_SPEC_HERE]") {
-        log("⚠  AXL_SPEC placeholder not replaced — AI quality will be degraded", "WARN");
-    }
 });