Update app.js

app.js

@@ -16,6 +16,8 @@
  *   5. DOWNLOAD endpoint returns dated filename.
  *   6. RPS throttle on AI calls, SAMPLES_PER_CALL configurable.
  *   7. AWS BEDROCK updated to ConverseCommand with NodeHttpHandler.
+ *   8. [FIXED] Synthetic array strictly sliced to exact requested fraction.
+ *   9.[FIXED] SAMPLES_PER_CALL lowered to 4 to prevent AWS token truncation.
  *
  * Endpoints:
  *   GET  /status
@@ -45,12 +47,12 @@ import { NodeHttpHandler } from "@smithy/node-http-handler";
 // ── 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";
+const BEDROCK_MODEL_ID = "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 SAMPLES_PER_CALL = parseInt(process.env.SAMPLES_PER_CALL || "4"); // Reduced to prevent token cutoff
 const SCALE_K          = 30.0;
 const LATENT_D_MAX     = 8; 
 
@@ -392,7 +394,7 @@ function synthXorSamples(n) {
             `  END ENTITY`,
         ].join("\n")).join("\n");
 
-        const axl = [
+        const axl =[
             `SCOPE xor_bit_level[level: 0]`,
             `  ASSUME bit EXISTS`,
             `  ASSUME bit DISCRETE VALUES {0, 1}`,
@@ -405,20 +407,20 @@ function synthXorSamples(n) {
             bitEntities,
             `END SCOPE`,
             ``,
-            `SCOPE xor_byte_level [level: 1]`,
+            `SCOPE xor_byte_level[level: 1]`,
             `  ASSUME xor_bit_level SCOPE HOLDS`,
             `  ENTITY byte_assembler`,
-            `    FIELD value: INTEGER BOUND [0, 255]`,
+            `    FIELD value: INTEGER BOUND[0, 255]`,
             `    DERIVES value FROM {bit_7..bit_0} BY binary_weighted_sum`,
             `  END ENTITY`,
             `  CONSERVES bit_count ACROSS binary_weighted_sum`,
             `  ENTITY key_byte`,
-            `    FIELD raw:        INTEGER BOUND [0, 255]`,
+            `    FIELD raw:        INTEGER BOUND[0, 255]`,
             `    FIELD normalised: REAL    BOUND [0, 1]`,
             `    DERIVES normalised FROM raw BY divide_255`,
             `  END ENTITY`,
             `  ENTITY plain_byte`,
-            `    FIELD raw: INTEGER BOUND [0, 255] EQUALS ${plain}`,
+            `    FIELD raw: INTEGER BOUND[0, 255] EQUALS ${plain}`,
             `  END ENTITY`,
             `  ENTITY cipher_byte`,
             `    FIELD raw: INTEGER BOUND[0, 255]`,
@@ -444,11 +446,11 @@ function synthXorSamples(n) {
         samples.push({
             id: randomUUID(), domain: "cryptography", subdomain: "xor_byte",
             sense: "EQUAL", n_vars: 1,
-            vars_text: "VARS c0 IN[0 255]",
+            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: [key],
+            c_values:[key],
             mask: [1], candidates:[], step_count: 0, axl_source: axl,
             metadata: {
                 description: `XOR byte: plain=${plain} key=${key} → cipher=${cipher}`,
@@ -515,7 +517,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`,
@@ -534,7 +536,7 @@ function synthCaesarSamples(n) {
         samples.push({
             id: randomUUID(), domain: "cryptography", subdomain: "caesar",
             sense: "EQUAL", n_vars: 1,
-            vars_text: "VARS c0 IN [0 25]",
+            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),
@@ -573,7 +575,7 @@ function synthVigenereSamples(n) {
             `SCOPE alphabet_ring [level: 0]`,
             `  ASSUME integer EXISTS`,
             `  TRANSFORM modular_add_26`,
-            `    INPUT  {a: INTEGER BOUND [0,25], b: INTEGER BOUND [0,25]}`,
+            `    INPUT  {a: INTEGER BOUND [0,25], b: INTEGER BOUND[0,25]}`,
             `    OUTPUT {result: INTEGER BOUND [0,25]}`,
             `    PRODUCES result = (a + b) % 26`,
             `  END TRANSFORM`,
@@ -606,7 +608,7 @@ function synthVigenereSamples(n) {
             `  END ENTITY`,
             `  OBSERVE ciphertext_vector.chars EQUALS[${cipher.join(", ")}]`,
             `  OBSERVE SUM(ciphertext_vector.chars) EQUALS ${bRaw}`,
-            `  UNKNOWN key_vector.normalised: VECTOR OF REAL BOUND [0, 1]`,
+            `  UNKNOWN key_vector.normalised: VECTOR OF REAL BOUND[0, 1]`,
             `  COLLAPSE vigenere_composition`,
             `    GIVEN {plaintext_vector.chars, ciphertext_vector.chars}`,
             `    FIND  key_vector.normalised`,
@@ -651,7 +653,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`,
@@ -673,7 +675,7 @@ function synthAffineSamples(n) {
             `    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 a_norm: REAL    BOUND [0, 1]`,
+            `    FIELD a_norm: REAL    BOUND[0, 1]`,
             `    FIELD b_norm: REAL    BOUND [0, 1]`,
             `    DERIVES a     FROM a_idx BY lookup_valid_a`,
             `    DERIVES a_norm FROM a_idx BY divide_11`,
@@ -684,13 +686,11 @@ function synthAffineSamples(n) {
             `    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`,
@@ -698,7 +698,7 @@ function synthAffineSamples(n) {
             `  END CONTRADICT`,
             `  OBSERVE affine_transform_result.ciphertext EQUALS ${cipher}`,
             `  UNKNOWN affine_key.a_norm: REAL BOUND[0, 1]`,
-            `  UNKNOWN affine_key.b_norm: REAL BOUND [0, 1]`,
+            `  UNKNOWN affine_key.b_norm: REAL BOUND[0, 1]`,
             `  COLLAPSE affine_cipher`,
             `    GIVEN {affine_transform_result.plaintext, affine_transform_result.ciphertext}`,
             `    FIND  {affine_key.a_norm, affine_key.b_norm}`,
@@ -752,7 +752,7 @@ function synthOptimizationSamples(n) {
                 ``,
                 `  ENTITY decision_variables`,
                 ...Array.from({length:nVars},(_,j)=>
-                    `    FIELD c${j}: REAL BOUND [0, 1]`),
+                    `    FIELD c${j}: REAL BOUND[0, 1]`),
                 `  END ENTITY`,
                 ``,
                 `  ENTITY objective_function`,
@@ -898,7 +898,7 @@ existence conditions. An entity does not exist unless its
 REQUIRES clause is satisfied.
 
 ENTITY <name>
-  FIELD <name>: <type> [BOUND <range>] [CONSERVES] [DISCRETE]
+  FIELD <name>: <type>[BOUND <range>] [CONSERVES] [DISCRETE]
   STATE <name>: REQUIRES <condition>
   TENDS <field> <direction>
   DERIVES FROM <entity_list>
@@ -1295,7 +1295,7 @@ END SCOPE
 OBSERVE spectral_emission EQUALS {656nm, 486nm, 434nm, 410nm}
 
 UNKNOWN element: SYMBOLIC WITHIN periodic_table
-UNKNOWN atomic_number: INTEGER BOUND[1, 118]
+UNKNOWN atomic_number: INTEGER BOUND [1, 118]
 UNKNOWN electron_configuration: VECTOR
 
 COLLAPSE atom
@@ -1321,7 +1321,7 @@ axl:
 # the output must satisfy a bound.
 # ════════════════════════════════════════════════════
 
-SCOPE bitfield [level: 0]
+SCOPE bitfield[level: 0]
 
   ASSUME bit EXISTS
   ASSUME bit DISCRETE VALUES {0, 1}
@@ -1334,7 +1334,7 @@ SCOPE bitfield [level: 0]
 END SCOPE
 
 
-SCOPE sha256_internals [level: 1]
+SCOPE sha256_internals[level: 1]
 
   ASSUME bitfield SCOPE HOLDS
 
@@ -1541,7 +1541,7 @@ SCOPE genome[level: 1]
   END ENTITY
 
   ENTITY dna_polymerase
-    FIELD error_rate: REAL BOUND [1e-9, 1e-9] # one error per billion bases
+    FIELD error_rate: REAL BOUND[1e-9, 1e-9] # one error per billion bases
     TENDS accuracy MAX
     TRANSFORMS dna_strand INTO dna_strand_copy
     CONSERVES sequence UNLESS error_rate TRIGGERS
@@ -1749,7 +1749,7 @@ STRICT REQUIREMENTS:
 2. Every sample MUST have all fields in the schema below.
 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
+   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].
 5. Every vars_text MUST start with the word VARS.
 6. Every sample must use a DIFFERENT domain or structural pattern.
@@ -1769,7 +1769,7 @@ 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>,
@@ -1794,7 +1794,7 @@ OUTPUT THE JSON ARRAY NOW:`;
 
 async function callBedrock(prompt) {
     const command = new ConverseCommand({
-        modelId: BEDROCK_MODEL,
+        modelId: BEDROCK_MODEL_ID,
         messages: [{ role: "user", content:[{ text: prompt }] }],
         inferenceConfig: { 
             maxTokens: 10000, 
@@ -1875,14 +1875,22 @@ 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 raw of genFn(perGen)) {
-                if (!validateSample(raw)) { errors++; continue; }
-                const norm = normalizeSample(raw);
-                if (!norm) { errors++; continue; }
-                generated.push(norm);
-                tracker.record(norm.domain);
-            }
+        
+        let tempSynth =[];
+        for (const genFn of gens) {
+            tempSynth.push(...genFn(perGen));
+        }
+        
+        // Shuffle slightly for mix, then slice to EXACTLY nSynthetic
+        tempSynth.sort(() => 0.5 - Math.random());
+        tempSynth = tempSynth.slice(0, nSynthetic);
+
+        for (const raw of tempSynth) {
+            if (!validateSample(raw)) { errors++; continue; }
+            const norm = normalizeSample(raw);
+            if (!norm) { errors++; continue; }
+            generated.push(norm);
+            tracker.record(norm.domain);
         }
         log(`Synthetic: ${generated.length} valid`, "OK");
     }
@@ -1962,7 +1970,7 @@ app.get("/dataset/sample", (req, res) => {
 loadDataset();
 app.listen(PORT, '0.0.0.0', () => {
     log(`AXL Dataset Server listening on :${PORT}`, "OK");
-    log(`Model:   ${BEDROCK_MODEL}`);
+    log(`Model:   ${BEDROCK_MODEL_ID}`);
     log(`Dataset: ${DATASET_PATH}`);
     log(`RPS:     ${DEFAULT_RPS} default / ${MAX_RPS} max`);
 });