// model.js

export function createModel() {
  const model = tf.sequential();
  model.add(
    tf.layers.dense({
      inputShape: [8],
      units: 12,
      activation: "relu",
    })
  );
  model.add(
    tf.layers.dense({
      units: 1,
      activation: "sigmoid",
    })
  );
  model.compile({
    optimizer: "adam",
    loss: "binaryCrossentropy",
    metrics: ["accuracy"],
  });
  return model;
}

// Fake streams: build a row of 8 numbers, label 1 = “meaningful update”, 0 = skip
for (let i = 0; i < 700; i++) {
  // ... pick random delta, viewport, dwell, scroll, etc. ...
  rows.push([/* 8 normalized numbers */]);
  labels.push(/* 1 or 0 from your “meaningful” rule */);
}
await model.fit(tf.tensor2d(rows), tf.tensor2d(labels, [labels.length, 1]), {
  epochs: 20,
});

// Ask the model: should we commit this new count?
const p = model.predict(tf.tensor2d([[/* same 8 numbers, live */]])).dataSync()[0];

// Commit if model says “yes” OR huge jump safety rule
if (p > 0.52) {
  setLikeCount(nextCount); // ← this triggers React reconcile / flash in the demo
}

// 1. Collect features for each row in the same order as your list (or keep parallel arrays of rowId and feature row):
// rows[i] = [f0, f1, ... f(F-1)] for row i
const rows = items.map((item) => buildFeatures(item));

// 2. One tensor, one forward pass
const input = tf.tensor2d(rows);        // shape [n, F]
const output = model.predict(input);     // shape [n, 1] for your sigmoid head
const scores = Array.from(output.dataSync()); // length n
input.dispose();
output.dispose();

// 3. Map scores back to work
items.forEach((item, i) => {
  const p = scores[i];
  const shouldCommit = p > 0.52; // your threshold
  // apply or skip for item.id
});

	<div>
      <Chart />
      <Expenses />
      <Summary />
    </div>

let Chart = React.lazy(() => import('./Chart'));
let Expenses = React.lazy(() => import('./Expenses'));	
let Summary = React.lazy(() => import('./Summary'));	

...
...
...


<div>
  <Suspense fallback={<Loader />}>
    <Chart />
   </Suspense>
  <Suspense fallback={<Loader />}>
    <Expenses />
  </Suspense>
  <Suspense fallback={<Loader />}>
    <Summary />
  </Suspense>
</div>

const WIDGET_COUNT = 5;
function oneHot(widgetId) {
  return Array.from({ length: WIDGET_COUNT }, (_, i) => (i === widgetId ? 1 : 0));
}
// Example: widget 2 → [0, 0, 1, 0, 0]

function createPreferenceModel() {
  const model = tf.sequential();
  model.add(
    tf.layers.dense({
      inputShape: [5],
      units: 10,
      activation: "relu",
    })
  );
  model.add(
    tf.layers.dense({
      units: 1,
      activation: "sigmoid",
    })
  );
  model.compile({
    optimizer: "adam",
    loss: "meanSquaredError",
  });
  return model;
}

import * as tf from '@tensorflow/tfjs';

const model = tf.sequential();

model.add(tf.layers.lstm({
  units: 0,
  inputShape: [sequenceLength, linksCount]
}));

model.add(tf.layers.dense({
  units: linksCount,
  activation: 'sigmoid'
}));

import * as tf from '@tensorflow/tfjs';

async train (sequencesBatch, labelsBatch) {
  await this.model.fit(
  sqeuencesBatch, labelsBatch, {
    epochs: 30,
    validationSplit: 0.15
  });
}

import * as tf from '@tensorflow/tfjs';


model.predict(sequence);


// UI
 startPreloadTransition(() => {
   setPreloadedWidgetId(predictedWidget);
   setPreparedWidgetId(predictedWidget);
});

export function createBatchModel() {
  const model = tf.sequential();
  model.add(tf.layers.dense({ inputShape: [2], units: 6, activation: "relu" }));
  model.add(tf.layers.dense({ units: 1, activation: "sigmoid" }));
  model.compile({ optimizer: "adam", loss: "binaryCrossentropy" });
  return model;
}

for (let i = 0; i < 240; i++) {
  const absNetDelta = Math.random() * 8;
  const eventCount = 1 + Math.floor(Math.random() * 6);
  rows.push([absNetDelta / 8, eventCount / 6]);
  const meaningful = absNetDelta > 3.8 || eventCount >= 4 ? 1 : 0;
  labels.push(meaningful);
}


// model.js
const xs = tf.tensor2d(rows);
const ys = tf.tensor2d(labels, [labels.length, 1]);
await model.fit(xs, ys, { epochs: 10, verbose: 0 });

const FLUSH_MS = 360;
const eventBufferRef = useRef([]);
const flushRef = useRef(null);

const scheduleFlush = () => {
  if (flushRef.current) return;

  flushRef.current = setTimeout(async () => {
    const batch = [...eventBufferRef.current];
    eventBufferRef.current = [];
    flushRef.current = null;

    if (!batch.length || !modelRef.current) return;

    // → next block: merge, predict, set state once
    const summary = await summarizeBatch(batch, modelRef.current);

    setAiBoard((prev) => applyPatches(prev, summary.patches));
  }, FLUSH_MS);
};

// On each simulated tick (AI path only):
eventBufferRef.current.push({ cardId, delta });
scheduleFlush();

// Wrap your code in tf.tidy() to automatically clean up intermediate tensors, or manually call tensor.dispose() for long-lived ones.
useEffect(() => {
  const model = tf.sequential(); // Create simple model
  model.add(tf.layers.dense({ units: 1, inputShape: [1] }));

  // CLEANUP: React runs this when the component disappears
  return () => {
    model.dispose(); // Wipes the GPU memory
    console.log("Memory Cleaned");
  };
}, []);