«Подход»: что в подложке было ненастоящим

type Fields = Record<string, string | number | boolean>;
type Row = Fields & { id: string };
type Op = { opId: string; rowId: string; fields: Fields; at: number };
type Verdict = { opId: string; status: "applied" | "duplicate" | "rejected"; reason?: string };
interface Store {
  list(): Row[];
  visible(): Row[];
}
interface Journal {
  newId(): string;
  change(rowId: string, fields: Fields): void;
  remove(rowId: string): void;
  outbox(): Op[];
}
interface Server {
  rows: Map<string, Row>;
  journal: (Op & { seq: number })[];
  pull(cursor: number, limit: number): { changes: (Op & { seq: number })[]; cursor: number; hasMore: boolean };
}
interface Client {
  store: Store;
  journal: Journal;
  queue(): Op[];
  sync(): Verdict[];
}
declare function createServer(): Server;
declare function createClient(device: string, server: Server): Client;

const server = createServer();
const phone = createClient("A", server);
const set = phone.journal.newId();
phone.journal.change(set, { exercise: "жим", weightKg: 80, reps: 5 });
phone.journal.change(set, { weightKg: 82.5 });

const [first, second] = phone.journal.outbox();
console.log("имя строки:", first.rowId, "| имена операций:", first.opId, second.opId);
console.log("отметки времени:", first.at, second.at);

phone.sync();
const page = server.pull(0, 100);
console.log("pull ответил тем же выражением:", page.changes.length, "| это промис:", page instanceof Promise);

// «приложение перезапустили»: тот же телефон, клиент создаётся заново
const afterRestart = createClient("A", server);
console.log("после перезапуска в журнале:", afterRestart.journal.outbox().length);

phone.journal.remove(set);
phone.sync();
console.log("удалили: видно", phone.store.visible().length, "| строк у сервера", server.rows.size, "| записей в его журнале", server.journal.length);

type Fields = Record<string, string | number | boolean>;
type Row = Fields & { id: string };
type Op = { opId: string; rowId: string; fields: Fields; at: number };
type Verdict = { opId: string; status: "applied" | "duplicate" | "rejected"; reason?: string };
interface Store {
  visible(): Row[];
}
interface Journal {
  newId(): string;
  change(rowId: string, fields: Fields): void;
}
interface Server {
  rows: Map<string, Row>;
}
interface Client {
  store: Store;
  journal: Journal;
  sync(): Verdict[];
}
declare function createServer(): Server;
declare function createClient(device: string, server: Server, start?: number): Client;

// один и тот же случай: в зале правят вес, дома — повторы того же подхода
function bothEdit(zalName: string, homeName: string, zalStart: number, homeStart: number): string {
  const server = createServer();
  const zal = createClient(zalName, server, zalStart);
  const home = createClient(homeName, server, homeStart);
  const set = zal.journal.newId();
  zal.journal.change(set, { exercise: "жим", weightKg: 80, reps: 5 });
  zal.sync();
  home.sync();
  home.journal.change(set, { reps: 12 });
  zal.journal.change(set, { weightKg: 82.5 });
  home.sync();
  zal.sync();
  home.sync();
  const [row] = zal.store.visible();
  const { id, ...fields } = row;
  const same = JSON.stringify(zal.store.visible()) === JSON.stringify(home.store.visible());
  return JSON.stringify(fields) + " | имя строки " + id + " | устройства сошлись: " + same;
}

console.log("счётчики песочницы:", bothEdit("A", "B", 0, 0));
console.log("uuid и часы телефона:", bothEdit("3f2a91c4", "b7d0c418", 1768000000000, 1768000000500));

// shared/podhod/runtime.native.ts — телефон; рядом лежит runtime.web.ts с миниатюрами
import { randomUUID } from "expo-crypto";
import { openJournalDb } from "../db/journal-db";
import type { Runtime } from "./runtime.types";

// гибридные часы из статьи «Кто прав, если оба правы», но источник настоящий:
// время не идёт назад даже тогда, когда часы перевели руками
let seen = 0;

export const runtime: Runtime = {
  newDeviceId: () => randomUUID(),
  see: (at) => {
    seen = Math.max(seen, at);
  },
  now: () => {
    seen = Math.max(seen + 1, Date.now());
    return seen;
  },
  openDisk: openJournalDb,
};

# Android: убить процесс так же, как это делает система, когда ей нужна память
adb shell am kill com.podhod.app
# Android: «Не сохранять действия» — экран выбрасывается, едва вы с него ушли
adb shell settings put global always_finish_activities 1
# iOS: то же самое на симуляторе
xcrun simctl terminate booted com.podhod.app

type Fields = Record<string, string | number | boolean>;
type Row = Fields & { id: string };
type Op = { opId: string; rowId: string; fields: Fields; at: number };
type Verdict = { opId: string; status: "applied" | "duplicate" | "rejected"; reason?: string };
interface Store {
  apply(op: Op): Row;
  list(): Row[];
  visible(): Row[];
}
interface Journal {
  newId(): string;
  change(rowId: string, fields: Fields): void;
  remove(rowId: string): void;
}
interface Server {
  rows: Map<string, Row>;
  journal: (Op & { seq: number })[];
  pull(cursor: number, limit: number): { changes: (Op & { seq: number })[]; cursor: number; hasMore: boolean };
}
interface Client {
  journal: Journal;
  sync(): Verdict[];
}
declare function createStore(): Store;
declare function createServer(): Server;
declare function createClient(device: string, server: Server): Client;

const server = createServer();
const phone = createClient("A", server);
const ids = ["жим", "присед", "тяга"].map((exercise) => {
  const id = phone.journal.newId();
  phone.journal.change(id, { exercise, weightKg: 80, reps: 5 });
  return id;
});
// обычная неделя дневника: правки веса, правки повторов и одно удаление
ids.forEach((id, index) => phone.journal.change(id, { weightKg: 80 + index * 5 }));
phone.journal.change(ids[0], { reps: 6 });
phone.journal.change(ids[1], { reps: 3 });
phone.journal.remove(ids[2]);
phone.sync();

// новый телефон: своего журнала нет, курсор нулевой
const fresh = createStore();
let cursor = 0;
let moved = 0;
let hasMore = true;
while (hasMore) {
  const page = server.pull(cursor, 100);
  page.changes.forEach((entry) => fresh.apply(entry));
  moved += page.changes.length;
  cursor = page.cursor;
  hasMore = page.hasMore;
}
console.log("перенесено операций:", moved, "| строк собралось:", fresh.list().length, "| видно:", fresh.visible().length);
console.log("в журнале сервера записей:", server.journal.length, "| строк у него:", server.rows.size);

type Fields = Record<string, string | number | boolean>;
type Row = Fields & { id: string };
type Op = { opId: string; rowId: string; fields: Fields; at: number };
type Verdict = { opId: string; status: "applied" | "duplicate" | "rejected"; reason?: string };
interface Store {
  visible(): Row[];
}
interface Journal {
  newId(): string;
  change(rowId: string, fields: Fields): void;
  remove(rowId: string): void;
}
interface Server {
  rows: Map<string, Row>;
  net: { offline: boolean; loseResponse: boolean; unauthorized: boolean };
}
interface Client {
  store: Store;
  journal: Journal;
  queue(): Op[];
  sync(): Verdict[];
}
declare function createServer(): Server;
declare function createClient(device: string, server: Server): Client;

const server = createServer();
const phone = createClient("A", server);
const web = createClient("B", server);
const step = (title: string) =>
  console.log(title + ": на телефоне " + phone.store.visible().length + ", на вебе " + web.store.visible().length +
    " | ждут отправки " + phone.queue().length + " и " + web.queue().length);

server.net.offline = true;
const bench = phone.journal.newId();
phone.journal.change(bench, { exercise: "жим", weightKg: 80, reps: 5 });
const squat = phone.journal.newId();
phone.journal.change(squat, { exercise: "присед", weightKg: 100, reps: 5 });
try {
  phone.sync();
} catch (error) {
  console.log("зал:", (error as Error).message);
}
step("после зала");

server.net.offline = false;
phone.sync();
web.sync();
step("дома, после первой синхронизации");

// одно и то же время: на вебе правят повторы, на телефоне — вес того же подхода
web.journal.change(bench, { reps: 6 });
phone.journal.change(bench, { weightKg: 82.5 });
web.journal.remove(squat);
web.sync();
phone.sync();
web.sync();
step("после слияния");

const reference = [{ id: bench, exercise: "жим", weightKg: 82.5, reps: 6 }];
console.log("телефон:", JSON.stringify(phone.store.visible()));
console.log("эталон сошёлся:", JSON.stringify(phone.store.visible()) === JSON.stringify(reference),
  "| телефон и веб одинаковы:", JSON.stringify(phone.store.visible()) === JSON.stringify(web.store.visible()),
  "| строк у сервера:", server.rows.size);