@gamerdexapp/gamerdex-sync 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,829 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DATA_FILE: () => DATA_FILE,
+  GITHUB_APP: () => GITHUB_APP,
+  GitHubProvider: () => GitHubProvider,
+  META_FILE: () => META_FILE,
+  META_FORMAT: () => META_FORMAT,
+  MemoryProvider: () => MemoryProvider,
+  ProviderError: () => ProviderError,
+  ROOT_FOLDER: () => ROOT_FOLDER,
+  RemoteDataError: () => RemoteDataError,
+  SyncBusyError: () => SyncBusyError,
+  VersionConflictError: () => VersionConflictError,
+  authorizeUrl: () => authorizeUrl,
+  createTokenSource: () => createTokenSource,
+  dataPath: () => dataPath,
+  decodeBase64: () => decodeBase64,
+  emptyMeta: () => emptyMeta,
+  encodeBase64: () => encodeBase64,
+  equal: () => equal,
+  installUrl: () => installUrl,
+  isAppId: () => isAppId,
+  isObject: () => isObject,
+  listInstalledRepositories: () => listInstalledRepositories,
+  merge: () => merge,
+  metaPath: () => metaPath,
+  newState: () => newState,
+  parseMeta: () => parseMeta,
+  parseTokenResponse: () => parseTokenResponse,
+  readCallback: () => readCallback,
+  resolveConflict: () => resolveConflict,
+  restoreCloudValues: () => restoreCloudValues,
+  sync: () => sync,
+  toStoredTokens: () => toStoredTokens,
+  withChiefRemoved: () => withChiefRemoved,
+  withChiefRevision: () => withChiefRevision,
+  withDevice: () => withDevice,
+  withSettingsRevision: () => withSettingsRevision
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/layout.ts
+var ROOT_FOLDER = "Gamerdex";
+var DATA_FILE = "data.json";
+var META_FILE = "meta.json";
+var APP_ID = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+var isAppId = (value) => APP_ID.test(value);
+var folderOf = (appId) => {
+  if (!isAppId(appId)) throw new RangeError(`Invalid app id: ${appId}`);
+  return `${ROOT_FOLDER}/${appId}`;
+};
+var dataPath = (appId) => `${folderOf(appId)}/${DATA_FILE}`;
+var metaPath = (appId) => `${folderOf(appId)}/${META_FILE}`;
+
+// src/meta.ts
+var META_FORMAT = 1;
+var emptyMeta = (appId) => ({
+  format: META_FORMAT,
+  appId,
+  revisions: {},
+  settingsRevision: 0,
+  removed: {},
+  devices: {},
+  lastSyncAt: null
+});
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isCounter = (value) => typeof value === "number" && Number.isInteger(value) && value >= 0;
+var isCounterMap = (value) => isRecord(value) && Object.values(value).every(isCounter);
+var isDevice = (value) => isRecord(value) && typeof value.name === "string" && typeof value.lastSeenAt === "string";
+var parseMeta = (text, appId) => {
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    return { ok: false, error: "The meta file is not valid JSON." };
+  }
+  if (!isRecord(value)) return { ok: false, error: "The meta file is not an object." };
+  if (value.format !== META_FORMAT) return { ok: false, error: "The meta format is not known." };
+  if (value.appId !== appId) return { ok: false, error: "The meta file belongs to another app." };
+  if (!isCounterMap(value.revisions)) return { ok: false, error: "The revisions are not valid." };
+  if (!isCounter(value.settingsRevision)) {
+    return { ok: false, error: "The settings revision is not valid." };
+  }
+  if (!isCounterMap(value.removed)) return { ok: false, error: "The removed list is not valid." };
+  if (!isRecord(value.devices) || !Object.values(value.devices).every(isDevice)) {
+    return { ok: false, error: "The devices are not valid." };
+  }
+  if (value.lastSyncAt !== null && typeof value.lastSyncAt !== "string") {
+    return { ok: false, error: "The last sync time is not valid." };
+  }
+  return { ok: true, meta: value };
+};
+var withChiefRevision = (meta, chiefId) => {
+  return {
+    ...meta,
+    revisions: { ...meta.revisions, [chiefId]: (meta.revisions[chiefId] ?? 0) + 1 },
+    removed: Object.fromEntries(Object.entries(meta.removed).filter(([id]) => id !== chiefId))
+  };
+};
+var withChiefRemoved = (meta, chiefId) => {
+  const revision = (meta.revisions[chiefId] ?? 0) + 1;
+  return {
+    ...meta,
+    revisions: { ...meta.revisions, [chiefId]: revision },
+    removed: { ...meta.removed, [chiefId]: revision }
+  };
+};
+var withSettingsRevision = (meta) => ({
+  ...meta,
+  settingsRevision: meta.settingsRevision + 1
+});
+var withDevice = (meta, deviceId, device) => ({
+  ...meta,
+  devices: { ...meta.devices, [deviceId]: device },
+  lastSyncAt: device.lastSeenAt
+});
+
+// src/merge/equal.ts
+var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var equal = (a, b) => {
+  if (a === b) return true;
+  if (Array.isArray(a)) {
+    return Array.isArray(b) && a.length === b.length && a.every((item, i) => equal(item, b[i]));
+  }
+  if (isObject(a) && isObject(b)) {
+    const keys = Object.keys(a);
+    return keys.length === Object.keys(b).length && keys.every((key) => Object.hasOwn(b, key) && equal(a[key], b[key]));
+  }
+  return false;
+};
+
+// src/merge/cloud.ts
+var own = (value, key) => Object.hasOwn(value, key) ? value[key] : void 0;
+var childSchema = (schema, key) => (schema.fields && Object.hasOwn(schema.fields, key) ? schema.fields[key] : void 0) ?? schema.each ?? { type: "record" };
+var holdsDeviceValue = (schema) => {
+  if (schema.type === "local") return true;
+  if (schema.type === "keyed") return holdsDeviceValue(schema.item);
+  if (schema.type !== "object") return false;
+  return schema.each !== void 0 && holdsDeviceValue(schema.each) || Object.values(schema.fields ?? {}).some(holdsDeviceValue);
+};
+var restoreCloudValues = (merged, remote, schema) => {
+  if (schema.type === "local") return remote;
+  if (!holdsDeviceValue(schema)) return merged;
+  if (schema.type === "object" && isObject(merged) && (isObject(remote) || remote === void 0)) {
+    const cloud = remote ?? {};
+    const result = {};
+    for (const key of /* @__PURE__ */ new Set([...Object.keys(merged), ...Object.keys(cloud)])) {
+      const child = childSchema(schema, key);
+      const value = restoreCloudValues(own(merged, key), own(cloud, key), child);
+      if (value !== void 0) result[key] = value;
+    }
+    return result;
+  }
+  if (schema.type === "keyed" && Array.isArray(merged) && Array.isArray(remote)) {
+    const remoteById = new Map(
+      remote.filter(isObject).map((item) => [item[schema.key], item])
+    );
+    return merged.map(
+      (item) => isObject(item) ? restoreCloudValues(item, remoteById.get(item[schema.key]), schema.item) : item
+    );
+  }
+  return merged;
+};
+
+// src/merge/merge.ts
+var own2 = (map, key) => map !== void 0 && Object.hasOwn(map, key) ? map[key] : void 0;
+var record = (base, local, remote, path, context) => {
+  context.conflicts.push({
+    path,
+    kind: "both-changed",
+    base,
+    local,
+    remote,
+    taken: context.prefer
+  });
+  return context.prefer === "local" ? local : remote;
+};
+var joinLists = (base, local, remote) => {
+  const has = (list, value) => list.some((item) => equal(item, value));
+  const kept = (value) => {
+    const inBase = has(base, value);
+    const inLocal = has(local, value);
+    const inRemote = has(remote, value);
+    return inBase ? inLocal && inRemote : inLocal || inRemote;
+  };
+  const result = [];
+  for (const value of [...local, ...remote]) {
+    if (kept(value) && !has(result, value)) result.push(value);
+  }
+  return result;
+};
+var entriesOf = (list, key) => {
+  const entries = /* @__PURE__ */ new Map();
+  for (const item of list) {
+    if (!isObject(item) || typeof item[key] !== "string") return null;
+    entries.set(item[key], item);
+  }
+  return entries;
+};
+var mergeEntries = (ids, pick, schemaOf, path, context, deleteWins) => {
+  const merged = /* @__PURE__ */ new Map();
+  for (const id of ids) {
+    const [base, local, remote] = pick(id);
+    const value = mergeNode(base, local, remote, schemaOf(id), [...path, id], context, deleteWins);
+    if (value !== void 0) merged.set(id, value);
+  }
+  return merged;
+};
+var orderedIds = (local, remote, base) => [
+  .../* @__PURE__ */ new Set([...local, ...remote, ...base])
+];
+var mergeNode = (base, local, remote, schema, path, context, deleteWins) => {
+  if (schema.type === "local") return local;
+  if (equal(local, remote)) return local;
+  if (equal(local, base)) return remote;
+  if (equal(remote, base)) return local;
+  if (local === void 0 || remote === void 0) {
+    if (deleteWins) return void 0;
+    const taken = local === void 0 ? "remote" : "local";
+    context.conflicts.push({ path, kind: "delete-edit", base, local, remote, taken });
+    return taken === "local" ? local : remote;
+  }
+  switch (schema.type) {
+    case "max": {
+      const l = schema.order(local);
+      const r = schema.order(remote);
+      if (l === r) return record(base, local, remote, path, context);
+      return l > r ? local : remote;
+    }
+    case "join":
+      if (Array.isArray(local) && Array.isArray(remote)) {
+        return joinLists(Array.isArray(base) ? base : [], local, remote);
+      }
+      return record(base, local, remote, path, context);
+    case "object": {
+      if (!isObject(local) || !isObject(remote)) return record(base, local, remote, path, context);
+      const baseObject = isObject(base) ? base : {};
+      const ids = orderedIds(Object.keys(local), Object.keys(remote), Object.keys(baseObject));
+      const merged = mergeEntries(
+        ids,
+        (id) => [own2(baseObject, id), own2(local, id), own2(remote, id)],
+        (id) => own2(schema.fields, id) ?? schema.each ?? { type: "record" },
+        path,
+        context,
+        deleteWins || schema.deleteWins === true
+      );
+      return Object.fromEntries(merged);
+    }
+    case "keyed": {
+      const localEntries = Array.isArray(local) ? entriesOf(local, schema.key) : null;
+      const remoteEntries = Array.isArray(remote) ? entriesOf(remote, schema.key) : null;
+      const baseEntries = (Array.isArray(base) ? entriesOf(base, schema.key) : null) ?? /* @__PURE__ */ new Map();
+      if (!localEntries || !remoteEntries) return record(base, local, remote, path, context);
+      const ids = orderedIds(localEntries.keys(), remoteEntries.keys(), baseEntries.keys());
+      const merged = mergeEntries(
+        ids,
+        (id) => [baseEntries.get(id), localEntries.get(id), remoteEntries.get(id)],
+        () => schema.item,
+        path,
+        context,
+        deleteWins || schema.deleteWins === true
+      );
+      return [...merged.values()];
+    }
+    case "record":
+      return record(base, local, remote, path, context);
+  }
+};
+var merge = ({
+  base,
+  local,
+  remote,
+  schema,
+  prefer = "remote"
+}) => {
+  const context = { prefer, conflicts: [] };
+  const merged = mergeNode(base, local, remote, schema, [], context, false);
+  return {
+    merged,
+    cloud: restoreCloudValues(merged, remote, schema),
+    conflicts: context.conflicts
+  };
+};
+
+// src/merge/resolve.ts
+var own3 = (value, key) => Object.hasOwn(value, key) ? value[key] : void 0;
+var childSchema2 = (schema, step) => {
+  if (schema.type === "object") {
+    const named = schema.fields && Object.hasOwn(schema.fields, step) ? schema.fields[step] : void 0;
+    return named ?? schema.each ?? { type: "record" };
+  }
+  return { type: "record" };
+};
+var setAt = (data, schema, path, value) => {
+  if (path.length === 0) return value;
+  const [step, ...rest] = path;
+  if (schema.type === "keyed") {
+    const list = Array.isArray(data) ? data : [];
+    const index = list.findIndex((item) => isObject(item) && item[schema.key] === step);
+    const next2 = setAt(index >= 0 ? list[index] : void 0, schema.item, rest, value);
+    if (index < 0) return next2 === void 0 ? list : [...list, next2];
+    if (next2 === void 0) return list.filter((_, i) => i !== index);
+    return list.map((item, i) => i === index ? next2 : item);
+  }
+  const object = isObject(data) ? data : {};
+  const next = setAt(own3(object, step), childSchema2(schema, step), rest, value);
+  if (next === void 0) {
+    return Object.fromEntries(Object.entries(object).filter(([key]) => key !== step));
+  }
+  return { ...object, [step]: next };
+};
+var resolveConflict = (merged, schema, conflict, side) => setAt(merged, schema, conflict.path, conflict[side]);
+
+// src/provider/base64.ts
+var CHUNK = 32768;
+var encodeBase64 = (text) => {
+  const bytes = new TextEncoder().encode(text);
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += CHUNK) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK));
+  }
+  return btoa(binary);
+};
+var decodeBase64 = (base64) => {
+  const binary = atob(base64.replace(/\s/g, ""));
+  return new TextDecoder().decode(Uint8Array.from(binary, (char) => char.charCodeAt(0)));
+};
+
+// src/provider/types.ts
+var VersionConflictError = class extends Error {
+  constructor(path) {
+    super(`The file ${path} changed in the cloud.`);
+    this.path = path;
+    this.name = "VersionConflictError";
+  }
+  path;
+};
+var ProviderError = class extends Error {
+  constructor(kind, message, status, retryAfterSeconds) {
+    super(message);
+    this.kind = kind;
+    this.status = status;
+    this.retryAfterSeconds = retryAfterSeconds;
+    this.name = "ProviderError";
+  }
+  kind;
+  status;
+  retryAfterSeconds;
+};
+
+// src/provider/github.ts
+var API = "https://api.github.com";
+var API_VERSION = "2022-11-28";
+var encodePath = (path) => path.split("/").map(encodeURIComponent).join("/");
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var retryAfterOf = (response) => {
+  const header = response.headers.get("retry-after");
+  if (header !== null && Number.isFinite(Number(header))) return Number(header);
+  const reset = response.headers.get("x-ratelimit-reset");
+  if (reset !== null && Number.isFinite(Number(reset))) {
+    return Math.max(0, Number(reset) - Math.floor(Date.now() / 1e3));
+  }
+  return void 0;
+};
+var GitHubProvider = class {
+  constructor(options) {
+    this.options = options;
+    this.send = options.fetch ?? ((...args) => globalThis.fetch(...args));
+  }
+  options;
+  send;
+  async read(path) {
+    const response = await this.request("GET", this.contentsUrl(path));
+    if (response.status === 404) return null;
+    await this.assertOk(response);
+    const body = await response.json();
+    if (typeof body.sha !== "string") throw this.invalid("The file has no version.");
+    if (body.encoding === "base64" && typeof body.content === "string") {
+      return { content: decodeBase64(body.content), version: body.sha };
+    }
+    if (body.encoding === "none") {
+      const raw = await this.request("GET", this.contentsUrl(path), void 0, {
+        Accept: "application/vnd.github.raw+json"
+      });
+      await this.assertOk(raw);
+      return { content: await raw.text(), version: body.sha };
+    }
+    throw this.invalid("The file content is not in a known encoding.");
+  }
+  async write(path, content, expectedVersion) {
+    const body = {
+      message: this.message(path),
+      content: encodeBase64(content)
+    };
+    if (expectedVersion !== null) body.sha = expectedVersion;
+    if (this.options.branch) body.branch = this.options.branch;
+    const response = await this.request("PUT", this.contentsUrl(path), body);
+    if (response.status === 409 || response.status === 422) throw new VersionConflictError(path);
+    await this.assertOk(response);
+    const result = await response.json();
+    const version = result.content?.sha;
+    if (typeof version !== "string") throw this.invalid("The write returned no version.");
+    return { version };
+  }
+  async remove(path, expectedVersion) {
+    const body = { message: this.message(path), sha: expectedVersion };
+    if (this.options.branch) body.branch = this.options.branch;
+    const response = await this.request("DELETE", this.contentsUrl(path), body);
+    if (response.status === 404) return;
+    if (response.status === 409 || response.status === 422) throw new VersionConflictError(path);
+    await this.assertOk(response);
+  }
+  /**
+   * Checks that the repository can be used: it exists, the token can write to it, and it is
+   * private. The saved data of a player must never sit in a public repository.
+   */
+  async checkRepository() {
+    const response = await this.request("GET", `${API}/repos/${this.options.repository}`);
+    await this.assertOk(response);
+    const body = await response.json();
+    if (!isRecord2(body) || typeof body.private !== "boolean") {
+      throw this.invalid("The repository answer is not understood.");
+    }
+    const permissions = isRecord2(body.permissions) ? body.permissions : {};
+    return {
+      private: body.private,
+      canWrite: permissions.push === true,
+      defaultBranch: typeof body.default_branch === "string" ? body.default_branch : "main"
+    };
+  }
+  contentsUrl(path) {
+    const base = `${API}/repos/${this.options.repository}/contents/${encodePath(path)}`;
+    return this.options.branch ? `${base}?ref=${encodeURIComponent(this.options.branch)}` : base;
+  }
+  message(path) {
+    return this.options.commitMessage?.(path) ?? `Gamerdex sync: ${path}`;
+  }
+  async request(method, url, body, headers = {}) {
+    const token = await this.options.getToken();
+    try {
+      return await this.send(url, {
+        method,
+        headers: {
+          Accept: "application/vnd.github+json",
+          Authorization: `Bearer ${token}`,
+          "X-GitHub-Api-Version": API_VERSION,
+          ...body ? { "Content-Type": "application/json" } : {},
+          ...headers
+        },
+        body: body ? JSON.stringify(body) : void 0
+      });
+    } catch {
+      throw new ProviderError("network", "GitHub could not be reached.");
+    }
+  }
+  async assertOk(response) {
+    if (response.ok) return;
+    const { status } = response;
+    if (status === 401) throw new ProviderError("auth", "The token is not valid.", status);
+    if (status === 403 || status === 429) {
+      const limited = status === 429 || response.headers.get("x-ratelimit-remaining") === "0";
+      if (limited) {
+        throw new ProviderError(
+          "rate-limit",
+          "GitHub limits the calls.",
+          status,
+          retryAfterOf(response)
+        );
+      }
+      throw new ProviderError("auth", "The token has no permission for the repository.", status);
+    }
+    if (status === 404)
+      throw new ProviderError("not-found", "The repository was not found.", status);
+    if (status >= 500) throw new ProviderError("server", "GitHub failed.", status);
+    throw this.invalid(`GitHub answered ${status}.`, status);
+  }
+  invalid(message, status) {
+    return new ProviderError("invalid", message, status);
+  }
+};
+
+// src/provider/memory.ts
+var MemoryProvider = class {
+  files = /* @__PURE__ */ new Map();
+  counter = 0;
+  async read(path) {
+    const file = this.files.get(path);
+    return file ? { content: file.content, version: String(file.counter) } : null;
+  }
+  async write(path, content, expectedVersion) {
+    const current = this.files.get(path);
+    const currentVersion = current ? String(current.counter) : null;
+    if (currentVersion !== expectedVersion) throw new VersionConflictError(path);
+    this.counter += 1;
+    this.files.set(path, { content, counter: this.counter });
+    return { version: String(this.counter) };
+  }
+  async remove(path, expectedVersion) {
+    const current = this.files.get(path);
+    if (current && String(current.counter) !== expectedVersion) {
+      throw new VersionConflictError(path);
+    }
+    this.files.delete(path);
+  }
+  /** The paths of the files that exist, in the order they were first written. */
+  paths() {
+    return [...this.files.keys()];
+  }
+};
+
+// src/sync/sync.ts
+var MAX_ATTEMPTS = 4;
+var RemoteDataError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RemoteDataError";
+  }
+};
+var SyncBusyError = class extends Error {
+  constructor() {
+    super("The cloud kept changing during the sync.");
+    this.name = "SyncBusyError";
+  }
+};
+var parseData = (text, validate) => {
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    throw new RemoteDataError("The synced data is not valid JSON.");
+  }
+  if (validate && !validate(data)) throw new RemoteDataError("The synced data is not valid.");
+  return data;
+};
+var readMeta = (text, appId) => {
+  if (text === void 0) return emptyMeta(appId);
+  const parsed = parseMeta(text, appId);
+  if (!parsed.ok) throw new RemoteDataError(parsed.error);
+  return parsed.meta;
+};
+var writeMeta = async (options) => {
+  const { provider, appId, deviceId, deviceName, updateMeta, now } = options;
+  for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt += 1) {
+    const current = await provider.read(metaPath(appId));
+    const meta = readMeta(current?.content, appId);
+    const time = now();
+    const updated = withDevice(updateMeta ? updateMeta(meta) : meta, deviceId, {
+      name: deviceName,
+      lastSeenAt: time
+    });
+    try {
+      const written = await provider.write(
+        metaPath(appId),
+        JSON.stringify({ ...updated, lastSyncAt: time }, null, 2),
+        current?.version ?? null
+      );
+      return written.version;
+    } catch (error) {
+      if (!(error instanceof VersionConflictError)) throw error;
+    }
+  }
+  throw new SyncBusyError();
+};
+var sync = async (options) => {
+  const { appId, provider, schema, local, state, firstSync, validate } = options;
+  const path = dataPath(appId);
+  for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt += 1) {
+    const file = await provider.read(path);
+    if (file === null) {
+      if (validate && !validate(local))
+        throw new RemoteDataError("The data of this device is not valid.");
+      const cloud = restoreCloudValues(local, void 0, schema);
+      const created = await tryWrite(provider, path, cloud, null);
+      if (created === null) continue;
+      const metaVersion2 = await writeMeta(options);
+      return done(local, cloud, created, metaVersion2, [], true);
+    }
+    const remote = parseData(file.content, validate);
+    const differs = state === null && !equal(restoreCloudValues(local, remote, schema), remote);
+    const choice = differs ? firstSync : void 0;
+    if (differs && choice === void 0) return { status: "needs-choice", local, remote };
+    const base = state === null ? void 0 : state.base;
+    const merged = mergeFor(choice, { base, local, remote, schema });
+    if (validate && !validate(merged.merged)) {
+      throw new RemoteDataError("The merged data is not valid.");
+    }
+    if (equal(merged.cloud, remote)) {
+      const metaVersion2 = await writeMeta(options);
+      return done(merged.merged, merged.cloud, file.version, metaVersion2, merged.conflicts, false);
+    }
+    const version = await tryWrite(provider, path, merged.cloud, file.version);
+    if (version === null) continue;
+    const metaVersion = await writeMeta(options);
+    return done(merged.merged, merged.cloud, version, metaVersion, merged.conflicts, true);
+  }
+  throw new SyncBusyError();
+};
+var mergeFor = (choice, input) => {
+  if (choice === "keep-local") {
+    const cloud = restoreCloudValues(input.local, input.remote, input.schema);
+    return { merged: input.local, cloud, conflicts: [] };
+  }
+  if (choice === "keep-cloud") {
+    const merged = restoreCloudValues(input.remote, input.local, input.schema);
+    return { merged, cloud: input.remote, conflicts: [] };
+  }
+  return merge(input);
+};
+var tryWrite = async (provider, path, data, version) => {
+  try {
+    return (await provider.write(path, JSON.stringify(data, null, 2), version)).version;
+  } catch (error) {
+    if (error instanceof VersionConflictError) return null;
+    throw error;
+  }
+};
+var done = (data, cloud, dataVersion, metaVersion, conflicts, uploaded) => ({
+  status: "synced",
+  data,
+  state: { base: cloud, dataVersion, metaVersion },
+  conflicts,
+  uploaded
+});
+
+// src/auth/app.ts
+var GITHUB_APP = {
+  slug: "gamerdex-sync",
+  clientId: "Iv23liwzjj3x8O2K5ALA"
+};
+
+// src/auth/tokens.ts
+var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isSeconds = (value) => typeof value === "number" && Number.isFinite(value) && value > 0;
+var parseTokenResponse = (body) => {
+  if (!isRecord3(body)) return null;
+  const { accessToken, expiresIn, refreshToken, refreshExpiresIn } = body;
+  if (typeof accessToken !== "string" || accessToken === "") return null;
+  if (typeof refreshToken !== "string" || refreshToken === "") return null;
+  if (!isSeconds(expiresIn) || !isSeconds(refreshExpiresIn)) return null;
+  return { accessToken, expiresIn, refreshToken, refreshExpiresIn };
+};
+var toStoredTokens = (response, nowMs) => ({
+  accessToken: response.accessToken,
+  accessExpiresAt: nowMs + response.expiresIn * 1e3,
+  refreshToken: response.refreshToken,
+  refreshExpiresAt: nowMs + response.refreshExpiresIn * 1e3
+});
+
+// src/auth/source.ts
+var RENEW_BEFORE_MS = 6e4;
+var createTokenSource = (options) => {
+  const send = options.fetch ?? ((...args) => globalThis.fetch(...args));
+  let renewing = null;
+  const post = async (path, body) => {
+    let response;
+    try {
+      response = await send(`${options.endpoint}/${path}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      });
+    } catch {
+      throw new ProviderError("network", "The sign in service could not be reached.");
+    }
+    if (response.status >= 500) throw new ProviderError("server", "The sign in service failed.");
+    const parsed = response.ok ? parseTokenResponse(await response.json().catch(() => null)) : null;
+    if (parsed === null)
+      throw new ProviderError("auth", "The sign in was refused.", response.status);
+    const tokens = toStoredTokens(parsed, options.now());
+    options.save(tokens);
+    return tokens;
+  };
+  const renew = (tokens) => {
+    if (tokens.refreshExpiresAt <= options.now()) {
+      options.save(null);
+      throw new ProviderError("auth", "The sign in expired.");
+    }
+    renewing ??= post("refresh", { refreshToken: tokens.refreshToken }).catch((error) => {
+      if (error instanceof ProviderError && error.kind === "auth") options.save(null);
+      throw error;
+    }).finally(() => {
+      renewing = null;
+    });
+    return renewing;
+  };
+  return {
+    /** Finishes a sign in with the code from the callback page. */
+    signIn: (code, redirectUri) => post("token", { code, redirectUri }),
+    signOut: () => options.save(null),
+    isSignedIn: () => options.load() !== null,
+    getToken: async () => {
+      const tokens = options.load();
+      if (tokens === null) throw new ProviderError("auth", "The player is not signed in.");
+      if (tokens.accessExpiresAt - RENEW_BEFORE_MS > options.now()) return tokens.accessToken;
+      return (await renew(tokens)).accessToken;
+    }
+  };
+};
+
+// src/auth/urls.ts
+var newState = () => crypto.randomUUID();
+var authorizeUrl = (redirectUri, state) => {
+  const query = new URLSearchParams({
+    client_id: GITHUB_APP.clientId,
+    redirect_uri: redirectUri,
+    state
+  });
+  return `https://github.com/login/oauth/authorize?${query}`;
+};
+var installUrl = (state) => `https://github.com/apps/${GITHUB_APP.slug}/installations/new?${new URLSearchParams({ state })}`;
+var readCallback = (search, expectedState) => {
+  const query = new URLSearchParams(search);
+  if (query.get("error") !== null) return { ok: false, reason: "denied" };
+  const code = query.get("code");
+  if (code === null || code === "") return { ok: false, reason: "missing" };
+  if (expectedState === null || query.get("state") !== expectedState) {
+    return { ok: false, reason: "state" };
+  }
+  return { ok: true, code };
+};
+
+// src/provider/repositories.ts
+var API2 = "https://api.github.com";
+var PAGE_SIZE = 100;
+var isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var getJson = async (send, token, url) => {
+  let response;
+  try {
+    response = await send(url, {
+      headers: {
+        Accept: "application/vnd.github+json",
+        Authorization: `Bearer ${token}`,
+        "X-GitHub-Api-Version": "2022-11-28"
+      }
+    });
+  } catch {
+    throw new ProviderError("network", "GitHub could not be reached.");
+  }
+  if (response.status === 401 || response.status === 403) {
+    throw new ProviderError("auth", "The token is not valid.", response.status);
+  }
+  if (response.status >= 500) throw new ProviderError("server", "GitHub failed.", response.status);
+  const body = response.ok ? await response.json().catch(() => null) : null;
+  if (!isRecord4(body))
+    throw new ProviderError("invalid", "GitHub answer is not understood.", response.status);
+  return body;
+};
+var listInstalledRepositories = async (token, send = (...args) => globalThis.fetch(...args)) => {
+  const installations = await getJson(
+    send,
+    token,
+    `${API2}/user/installations?per_page=${PAGE_SIZE}`
+  );
+  const ids = (Array.isArray(installations.installations) ? installations.installations : []).filter(isRecord4).map((installation) => installation.id).filter((id) => typeof id === "number");
+  const repositories = [];
+  for (const id of ids) {
+    const page = await getJson(
+      send,
+      token,
+      `${API2}/user/installations/${id}/repositories?per_page=${PAGE_SIZE}`
+    );
+    for (const item of Array.isArray(page.repositories) ? page.repositories : []) {
+      if (isRecord4(item) && typeof item.full_name === "string" && typeof item.private === "boolean") {
+        repositories.push({ fullName: item.full_name, private: item.private });
+      }
+    }
+  }
+  return repositories;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DATA_FILE,
+  GITHUB_APP,
+  GitHubProvider,
+  META_FILE,
+  META_FORMAT,
+  MemoryProvider,
+  ProviderError,
+  ROOT_FOLDER,
+  RemoteDataError,
+  SyncBusyError,
+  VersionConflictError,
+  authorizeUrl,
+  createTokenSource,
+  dataPath,
+  decodeBase64,
+  emptyMeta,
+  encodeBase64,
+  equal,
+  installUrl,
+  isAppId,
+  isObject,
+  listInstalledRepositories,
+  merge,
+  metaPath,
+  newState,
+  parseMeta,
+  parseTokenResponse,
+  readCallback,
+  resolveConflict,
+  restoreCloudValues,
+  sync,
+  toStoredTokens,
+  withChiefRemoved,
+  withChiefRevision,
+  withDevice,
+  withSettingsRevision
+});
+//# sourceMappingURL=index.js.map