@the_library/public 1.0.0

package/dist/chunk-JDUYLUDJ.js

@@ -0,0 +1,4835 @@
+import {
+  bulkAddPatches,
+  getAllPatchesByUsername,
+  getAllPatchesSince,
+  instanceRemapsStoreName
+} from "./chunk-ZEZGI2TP.js";
+
+// ../db_schemas/dist/index.js
+var PatchOperation = /* @__PURE__ */ ((PatchOperation2) => {
+  PatchOperation2[PatchOperation2["EditPropertyString"] = 1] = "EditPropertyString";
+  PatchOperation2[PatchOperation2["EditPropertyNumber"] = 2] = "EditPropertyNumber";
+  PatchOperation2[PatchOperation2["EditInstanceFieldString"] = 3] = "EditInstanceFieldString";
+  PatchOperation2[PatchOperation2["EditInstanceFieldNumber"] = 4] = "EditInstanceFieldNumber";
+  PatchOperation2[PatchOperation2["EditRelation"] = 5] = "EditRelation";
+  PatchOperation2[PatchOperation2["SetAlias"] = 6] = "SetAlias";
+  PatchOperation2[PatchOperation2["CreateRecord"] = 7] = "CreateRecord";
+  PatchOperation2[PatchOperation2["AddInstance"] = 8] = "AddInstance";
+  return PatchOperation2;
+})(PatchOperation || {});
+var PatchAction = /* @__PURE__ */ ((PatchAction2) => {
+  PatchAction2[PatchAction2["Remove"] = 0] = "Remove";
+  PatchAction2[PatchAction2["Add"] = 1] = "Add";
+  return PatchAction2;
+})(PatchAction || {});
+var LANG_ID_ENCODE = {
+  eng: 1,
+  fra: 2,
+  spa: 3,
+  por: 4,
+  deu: 5,
+  zho: 6,
+  ara: 7,
+  rus: 8,
+  jpn: 9,
+  kor: 10,
+  hin: 11,
+  ita: 12,
+  nld: 13,
+  pol: 14,
+  swe: 15,
+  tur: 16,
+  vie: 17,
+  ind: 18,
+  tha: 19,
+  fas: 20,
+  heb: 21,
+  ukr: 22,
+  // Ethiopian traditions (the "Bible Problem" founding example):
+  amh: 23,
+  gez: 24,
+  tir: 25,
+  orm: 26,
+  cat: 27
+};
+var LANG_ID_DECODE = Object.fromEntries(
+  Object.entries(LANG_ID_ENCODE).map(([k, v]) => [v, k])
+);
+function resolveLayout(version, versionsFile2) {
+  const merged = { hash: "", enums: {}, props: {}, instanceFields: {} };
+  for (let v = 1; v <= version; v++) {
+    const entry = versionsFile2.versions[v];
+    if (!entry) continue;
+    Object.assign(merged.enums, entry.enums);
+    Object.assign(merged.props, entry.props);
+    for (const [ot, fields] of Object.entries(entry.instanceFields)) {
+      merged.instanceFields[Number(ot)] = [...fields];
+    }
+    merged.hash = entry.hash;
+  }
+  return merged;
+}
+function getPropBits(layout, propertyId) {
+  return layout.props[propertyId]?.bits ?? 32;
+}
+function isSignedProp(layout, propertyId) {
+  const t = layout.props[propertyId]?.type;
+  return t === void 0 || t === "number";
+}
+function checked(value, bits, field) {
+  if (!Number.isInteger(value)) {
+    throw new Error(`[db_schema_v2] ${field} = ${value} is not an integer`);
+  }
+  if (bits === 32) {
+    if (value < 0 || value >= 2 ** 32) {
+      throw new Error(`[db_schema_v2] ${field} = ${value} exceeds its ${bits}-bit range`);
+    }
+    return BigInt(value >>> 0);
+  } else {
+    if (value < 0 || value >= 2 ** bits) {
+      throw new Error(`[db_schema_v2] ${field} = ${value} exceeds its ${bits}-bit range (0..${2 ** bits - 1})`);
+    }
+    return BigInt(value);
+  }
+}
+function checkedValue(value, bits, signed) {
+  const ok = Number.isInteger(value) && (signed ? value >= -(2 ** (bits - 1)) && value < 2 ** (bits - 1) : value >= 0 && value < 2 ** bits);
+  if (!ok) {
+    throw new Error(
+      `[db_schema_v2] value = ${value} does not fit in ${bits} ${signed ? "signed" : "unsigned"} bits`
+    );
+  }
+  return BigInt(value) & (1n << BigInt(bits)) - 1n;
+}
+function packPatch(patch, layout) {
+  const op = BigInt(patch.operation);
+  if (patch.operation === 6) {
+    const p = patch;
+    return op | checked(p.objectType, 7, "objectType") << 4n | checked(p.fromUid, 32, "fromUid") << 11n | checked(p.toUid, 32, "toUid") << 43n;
+  }
+  if (patch.operation === 7) {
+    const p = patch;
+    if (p.objectId >>> 0 < 2147483648) {
+      throw new Error(`[db_schema_v2] CreateRecord objectId must have high bit set: ${p.objectId}`);
+    }
+    return op | checked(p.objectType, 7, "objectType") << 4n | checked(p.objectId, 32, "objectId") << 11n | 0n << 43n;
+  }
+  const bp = patch;
+  const base = op | checked(bp.objectType, 7, "objectType") << 4n | checked(bp.objectId, 32, "objectId") << 11n | checked(bp.langId, 8, "langId") << 43n;
+  switch (patch.operation) {
+    case 2: {
+      const p = patch;
+      const bits = getPropBits(layout, p.propertyId);
+      return base | checked(p.propertyId, 8, "propertyId") << 51n | checkedValue(p.value, bits, isSignedProp(layout, p.propertyId)) << 59n;
+    }
+    case 1: {
+      const p = patch;
+      return base | checked(p.propertyId, 8, "propertyId") << 51n;
+    }
+    case 4: {
+      const p = patch;
+      const bits = getPropBits(layout, p.propertyId);
+      return base | checked(p.instanceIndex, 8, "instanceIndex") << 51n | checked(p.propertyId, 8, "propertyId") << 59n | checkedValue(p.value, bits, isSignedProp(layout, p.propertyId)) << 67n;
+    }
+    case 3: {
+      const p = patch;
+      return base | checked(p.instanceIndex, 8, "instanceIndex") << 51n | checked(p.propertyId, 8, "propertyId") << 59n;
+    }
+    case 5: {
+      const p = patch;
+      return base | checked(p.relationId, 8, "relationId") << 51n | checked(p.action, 1, "action") << 59n | checked(p.targetId, 32, "targetId") << 60n;
+    }
+    case 8: {
+      const p = patch;
+      return base | checked(p.instanceIndex, 8, "instanceIndex") << 51n;
+    }
+    default:
+      throw new Error(`Unknown patch operation: ${patch.operation}`);
+  }
+}
+function unpackPatch(packed, layout) {
+  const opNum = Number(packed & 15n);
+  if (opNum === 6) {
+    return {
+      operation: 6,
+      objectType: Number(packed >> 4n & 127n),
+      fromUid: Number(packed >> 11n & 0xFFFFFFFFn),
+      toUid: Number(packed >> 43n & 0xFFFFFFFFn)
+    };
+  }
+  if (opNum === 7) {
+    const objectId2 = Number(packed >> 11n & 0xFFFFFFFFn);
+    if (objectId2 >>> 0 < 2147483648) {
+      throw new Error(`[db_schema_v2] CreateRecord objectId must have high bit set: ${objectId2}`);
+    }
+    return {
+      operation: 7,
+      objectType: Number(packed >> 4n & 127n),
+      objectId: objectId2,
+      langId: 0
+    };
+  }
+  const objectType = Number(packed >> 4n & 127n);
+  const objectId = Number(packed >> 11n & 0xFFFFFFFFn);
+  const langId = Number(packed >> 43n & 255n);
+  const base = { operation: opNum, objectType, objectId, langId };
+  switch (opNum) {
+    case 2: {
+      const propertyId = Number(packed >> 51n & 255n);
+      const bits = getPropBits(layout, propertyId);
+      const mask = (1n << BigInt(bits)) - 1n;
+      const raw = packed >> 59n & mask;
+      const value = isSignedProp(layout, propertyId) ? Number(BigInt.asIntN(bits, raw)) : Number(raw);
+      return { ...base, propertyId, value };
+    }
+    case 1: {
+      const propertyId = Number(packed >> 51n & 255n);
+      return { ...base, propertyId, value: "" };
+    }
+    case 4: {
+      const instanceIndex = Number(packed >> 51n & 255n);
+      const propertyId = Number(packed >> 59n & 255n);
+      const bits = getPropBits(layout, propertyId);
+      const mask = (1n << BigInt(bits)) - 1n;
+      const raw = packed >> 67n & mask;
+      const value = isSignedProp(layout, propertyId) ? Number(BigInt.asIntN(bits, raw)) : Number(raw);
+      return { ...base, instanceIndex, propertyId, value };
+    }
+    case 3: {
+      const instanceIndex = Number(packed >> 51n & 255n);
+      const propertyId = Number(packed >> 59n & 255n);
+      return { ...base, instanceIndex, propertyId, value: "" };
+    }
+    case 5: {
+      const relationId = Number(packed >> 51n & 255n);
+      const action = Number(packed >> 59n & 1n);
+      const targetId = Number(packed >> 60n & 0xFFFFFFFFn);
+      return { ...base, relationId, action, targetId };
+    }
+    case 8: {
+      const instanceIndex = Number(packed >> 51n & 255n);
+      return { ...base, instanceIndex };
+    }
+    default:
+      throw new Error(`Unknown packed operation: ${opNum}`);
+  }
+}
+function patchToEvm(patches, layout, version) {
+  const result = [];
+  const textIndex = [];
+  const textData = [];
+  for (let i = 0; i < patches.length; i++) {
+    const patch = patches[i];
+    result.push(packPatch(patch, layout));
+    if (patch.operation === 1) {
+      textIndex.push(i);
+      textData.push(patch.value);
+    } else if (patch.operation === 3) {
+      textIndex.push(i);
+      textData.push(patch.value);
+    }
+  }
+  return { version, patches: result, textIndex, textData };
+}
+function evmToPatch(payload, versionsFile2) {
+  const layout = resolveLayout(payload.version, versionsFile2);
+  const textMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < payload.textIndex.length; i++) {
+    textMap.set(payload.textIndex[i], payload.textData[i]);
+  }
+  return payload.patches.map((packed, i) => {
+    const patch = unpackPatch(packed, layout);
+    if (patch.operation === 1) {
+      patch.value = textMap.get(i) ?? "";
+    } else if (patch.operation === 3) {
+      patch.value = textMap.get(i) ?? "";
+    }
+    return patch;
+  });
+}
+
+// src/models/interfaces.ts
+var LANG_AGNOSTIC = "";
+var isEvmPatch = (item) => item.operation !== void 0;
+
+// src/models/dates.ts
+function monthDiff(d1, d2) {
+  var months;
+  months = (d2.getFullYear() - d1.getFullYear()) * 12;
+  months -= d1.getMonth();
+  months += d2.getMonth();
+  return months <= 0 ? 0 : months;
+}
+var zeroDate = new Date(2025, 4, 1);
+var inceptionDate = Math.floor(new Date(2025, 11, 1, 0, 0, 0).getTime() / 1e3);
+var DateUtils = {
+  now: () => Math.floor(Date.now() / 1e3) - inceptionDate,
+  serialize: (d) => {
+    const dv = new DataView(new ArrayBuffer(4));
+    dv.setUint32(0, d);
+    return dv.buffer;
+  },
+  toNumber: (d) => Math.floor(d.getTime() / 1e3),
+  fromNumber: (i) => new Date(i * 1e3),
+  findNowBucket: () => {
+    const now = /* @__PURE__ */ new Date();
+    if (now.getTime() < zeroDate.getTime()) {
+      throw new Error(`now ${now} is before zeroDate ${zeroDate}`);
+    }
+    return monthDiff(zeroDate, now);
+  },
+  findDateBucket: (d) => {
+    if (d.getTime() < zeroDate.getTime()) {
+      throw new Error(`now ${d} is before zeroDate ${zeroDate}`);
+    }
+    return monthDiff(zeroDate, d);
+  }
+};
+
+// src/models/enums.ts
+var ActionTypes = /* @__PURE__ */ ((ActionTypes2) => {
+  ActionTypes2[ActionTypes2["Visit"] = 0] = "Visit";
+  ActionTypes2[ActionTypes2["VisitPart"] = 1] = "VisitPart";
+  ActionTypes2[ActionTypes2["Download"] = 2] = "Download";
+  ActionTypes2[ActionTypes2["Rate"] = 3] = "Rate";
+  ActionTypes2[ActionTypes2["RatePart"] = 4] = "RatePart";
+  ActionTypes2[ActionTypes2["Share"] = 5] = "Share";
+  ActionTypes2[ActionTypes2["SharePart"] = 6] = "SharePart";
+  return ActionTypes2;
+})(ActionTypes || {});
+var WorkerCommands = /* @__PURE__ */ ((WorkerCommands2) => {
+  WorkerCommands2["Init"] = "init";
+  WorkerCommands2["SavePatches"] = "savePatches";
+  WorkerCommands2["GetRecord"] = "getRecord";
+  WorkerCommands2["LoadLanguage"] = "loadLanguage";
+  return WorkerCommands2;
+})(WorkerCommands || {});
+var Rating = /* @__PURE__ */ ((Rating2) => {
+  Rating2[Rating2["None"] = 0] = "None";
+  Rating2[Rating2["New"] = 1] = "New";
+  Rating2[Rating2["Keep"] = 2] = "Keep";
+  Rating2[Rating2["Trash"] = 3] = "Trash";
+  Rating2[Rating2["Shared"] = 4] = "Shared";
+  return Rating2;
+})(Rating || {});
+var WorkerEvent = /* @__PURE__ */ ((WorkerEvent2) => {
+  WorkerEvent2["WorkerReady"] = "workerready";
+  WorkerEvent2["WorkerLoadingError"] = "workerLoadingError";
+  WorkerEvent2["DownloadStarted"] = "downloadStarted";
+  WorkerEvent2["DownloadFinished"] = "downloadFinished";
+  WorkerEvent2["DownloadError"] = "downloadError";
+  WorkerEvent2["LevelUpdated"] = "levelUpdated";
+  return WorkerEvent2;
+})(WorkerEvent || {});
+var DownloadState = /* @__PURE__ */ ((DownloadState2) => {
+  DownloadState2[DownloadState2["Unknown"] = 0] = "Unknown";
+  DownloadState2[DownloadState2["Pending"] = 1] = "Pending";
+  DownloadState2[DownloadState2["InProgress"] = 2] = "InProgress";
+  DownloadState2[DownloadState2["Done"] = 3] = "Done";
+  DownloadState2[DownloadState2["Error"] = 4] = "Error";
+  return DownloadState2;
+})(DownloadState || {});
+var SidecarType = /* @__PURE__ */ ((SidecarType2) => {
+  SidecarType2[SidecarType2["Slim"] = 0] = "Slim";
+  SidecarType2[SidecarType2["Extended"] = 1] = "Extended";
+  SidecarType2[SidecarType2["Provenance"] = 2] = "Provenance";
+  return SidecarType2;
+})(SidecarType || {});
+
+// src/models/sanitizer.ts
+function sanitizeText(text) {
+  if (typeof text !== "string") return text;
+  let sanitized = text.replace(/<\/?[^>]+(>|$)/g, "");
+  const dangerousProtocols = /javascript:|data:|vbscript:|onclick|onerror|onload|onmouseover/gi;
+  sanitized = sanitized.replace(dangerousProtocols, "[REDACTED]");
+  return sanitized;
+}
+
+// ../db_schemas/dist/versions.js
+var versions_default = {
+  "current": 2,
+  "versions": {
+    "1": {
+      "hash": "de10ae90e292fd0d",
+      "enums": {
+        "BookMethod": {
+          "bits": 3,
+          "values": [
+            "Unknown",
+            "Scan",
+            "NativeDigital",
+            "OCR",
+            "AiTranslation"
+          ]
+        },
+        "CopyrightStatus": {
+          "bits": 2,
+          "values": [
+            "Unknown",
+            "PublicDomain",
+            "CreativeCommons",
+            "AllRightsReserved"
+          ]
+        },
+        "QualityScore": {
+          "bits": 3,
+          "values": [
+            "None",
+            "Poor",
+            "Fair",
+            "Good",
+            "VeryGood",
+            "Excellent"
+          ]
+        },
+        "RecordingStatus": {
+          "bits": 2,
+          "values": [
+            "Pending",
+            "Active",
+            "Completed",
+            "Archived"
+          ]
+        }
+      },
+      "props": {
+        "0": {
+          "name": "title",
+          "type": "string",
+          "bits": 0
+        },
+        "1": {
+          "name": "description",
+          "type": "string",
+          "bits": 0
+        },
+        "2": {
+          "name": "originalLang",
+          "type": "string",
+          "bits": 0
+        },
+        "3": {
+          "name": "ageGradeBand",
+          "type": "number",
+          "bits": 8
+        },
+        "4": {
+          "name": "previewTxId",
+          "type": "string",
+          "bits": 0
+        },
+        "5": {
+          "name": "safe",
+          "type": "boolean",
+          "bits": 1
+        },
+        "6": {
+          "name": "deleted",
+          "type": "boolean",
+          "bits": 1
+        },
+        "7": {
+          "name": "lifecycleStatus",
+          "type": "number",
+          "bits": 2
+        },
+        "8": {
+          "name": "prerequisites",
+          "type": "string",
+          "bits": 0
+        },
+        "9": {
+          "name": "deweyDecimal",
+          "type": "string",
+          "bits": 0
+        },
+        "10": {
+          "name": "locCallNumber",
+          "type": "string",
+          "bits": 0
+        },
+        "11": {
+          "name": "copyrightStatus",
+          "type": "enum",
+          "bits": 2,
+          "enum": "CopyrightStatus"
+        },
+        "12": {
+          "name": "textQuality",
+          "type": "enum",
+          "bits": 3,
+          "enum": "QualityScore"
+        },
+        "13": {
+          "name": "illustrations",
+          "type": "enum",
+          "bits": 3,
+          "enum": "QualityScore"
+        },
+        "14": {
+          "name": "educationQuality",
+          "type": "enum",
+          "bits": 3,
+          "enum": "QualityScore"
+        },
+        "15": {
+          "name": "practicality",
+          "type": "enum",
+          "bits": 3,
+          "enum": "QualityScore"
+        },
+        "16": {
+          "name": "accessibilityLevel",
+          "type": "enum",
+          "bits": 3,
+          "enum": "QualityScore"
+        },
+        "17": {
+          "name": "teacherMaterials",
+          "type": "boolean",
+          "bits": 1
+        },
+        "18": {
+          "name": "pedagogicalScaffolding",
+          "type": "enum",
+          "bits": 3,
+          "enum": "QualityScore"
+        },
+        "19": {
+          "name": "clarityOfExplanation",
+          "type": "enum",
+          "bits": 3,
+          "enum": "QualityScore"
+        },
+        "20": {
+          "name": "workedExamples",
+          "type": "enum",
+          "bits": 3,
+          "enum": "QualityScore"
+        },
+        "21": {
+          "name": "exercisesAndAssessment",
+          "type": "enum",
+          "bits": 3,
+          "enum": "QualityScore"
+        },
+        "22": {
+          "name": "selfStudyReadiness",
+          "type": "enum",
+          "bits": 3,
+          "enum": "QualityScore"
+        },
+        "23": {
+          "name": "referenceApparatus",
+          "type": "enum",
+          "bits": 3,
+          "enum": "QualityScore"
+        },
+        "24": {
+          "name": "safetyGuidance",
+          "type": "enum",
+          "bits": 3,
+          "enum": "QualityScore"
+        },
+        "25": {
+          "name": "contentCurrency",
+          "type": "enum",
+          "bits": 3,
+          "enum": "QualityScore"
+        },
+        "26": {
+          "name": "ecoRegeneration",
+          "type": "enum",
+          "bits": 3,
+          "enum": "QualityScore"
+        },
+        "27": {
+          "name": "communityLiving",
+          "type": "enum",
+          "bits": 3,
+          "enum": "QualityScore"
+        },
+        "28": {
+          "name": "promotesPeace",
+          "type": "enum",
+          "bits": 3,
+          "enum": "QualityScore"
+        },
+        "29": {
+          "name": "businessDevelopment",
+          "type": "enum",
+          "bits": 3,
+          "enum": "QualityScore"
+        },
+        "30": {
+          "name": "language",
+          "type": "string",
+          "bits": 0
+        },
+        "31": {
+          "name": "downloadTxId",
+          "type": "string",
+          "bits": 0
+        },
+        "32": {
+          "name": "method",
+          "type": "enum",
+          "bits": 3,
+          "enum": "BookMethod"
+        },
+        "33": {
+          "name": "isAiTranslation",
+          "type": "boolean",
+          "bits": 1
+        },
+        "34": {
+          "name": "aiEngine",
+          "type": "string",
+          "bits": 0
+        },
+        "35": {
+          "name": "addedAt",
+          "type": "number",
+          "bits": 32
+        },
+        "36": {
+          "name": "nbPages",
+          "type": "number",
+          "bits": 16
+        },
+        "37": {
+          "name": "sizeBytes",
+          "type": "number",
+          "bits": 32
+        },
+        "38": {
+          "name": "publisher",
+          "type": "string",
+          "bits": 0
+        },
+        "39": {
+          "name": "publicationDate",
+          "type": "string",
+          "bits": 0
+        },
+        "40": {
+          "name": "publishedAt",
+          "type": "string",
+          "bits": 0
+        },
+        "41": {
+          "name": "qualityScore",
+          "type": "enum",
+          "bits": 3,
+          "enum": "QualityScore"
+        },
+        "42": {
+          "name": "isbn",
+          "type": "string",
+          "bits": 0
+        },
+        "43": {
+          "name": "birthDate",
+          "type": "string",
+          "bits": 0
+        },
+        "44": {
+          "name": "deathDate",
+          "type": "string",
+          "bits": 0
+        },
+        "45": {
+          "name": "nationality",
+          "type": "string",
+          "bits": 0
+        },
+        "46": {
+          "name": "wikiUrl",
+          "type": "string",
+          "bits": 0
+        },
+        "47": {
+          "name": "isniId",
+          "type": "string",
+          "bits": 0
+        },
+        "48": {
+          "name": "orcidId",
+          "type": "string",
+          "bits": 0
+        },
+        "49": {
+          "name": "ddcNotation",
+          "type": "string",
+          "bits": 0
+        }
+      },
+      "instanceFields": {
+        "0": [
+          30,
+          31,
+          32,
+          33,
+          34,
+          35,
+          36,
+          37,
+          38,
+          39,
+          40,
+          41,
+          42
+        ]
+      }
+    },
+    "2": {
+      "hash": "1eb9d7d1ce54fb8d",
+      "enums": {},
+      "props": {
+        "50": {
+          "name": "lccNotation",
+          "type": "string",
+          "bits": 0
+        },
+        "51": {
+          "name": "udcNotation",
+          "type": "string",
+          "bits": 0
+        },
+        "52": {
+          "name": "clcNotation",
+          "type": "string",
+          "bits": 0
+        },
+        "53": {
+          "name": "bbkNotation",
+          "type": "string",
+          "bits": 0
+        },
+        "54": {
+          "name": "tlcNotation",
+          "type": "string",
+          "bits": 0
+        },
+        "55": {
+          "name": "ccNotation",
+          "type": "string",
+          "bits": 0
+        }
+      },
+      "instanceFields": {}
+    }
+  }
+};
+
+// src/models/versions.ts
+var versionsFile = versions_default;
+var CURRENT_VERSION = versionsFile.current;
+var _currentLayout = null;
+var currentLayout = () => {
+  if (!_currentLayout) {
+    _currentLayout = resolveLayout(CURRENT_VERSION, versionsFile);
+  }
+  return _currentLayout;
+};
+
+// src/models/patcher.ts
+function debouncePromise(func, wait) {
+  let timeout = null;
+  let resolves = [];
+  return (...args) => {
+    if (timeout !== null) {
+      clearTimeout(timeout);
+    }
+    const p = new Promise((resolve, reject) => {
+      resolves.push({ resolve, reject });
+    });
+    timeout = setTimeout(async () => {
+      timeout = null;
+      const currentResolves = [...resolves];
+      resolves = [];
+      try {
+        const result = await func(...args);
+        currentResolves.forEach((r) => r.resolve(result));
+      } catch (error) {
+        currentResolves.forEach((r) => r.reject(error));
+      }
+    }, wait);
+    return p;
+  };
+}
+var _Patches = class _Patches {
+  constructor(username) {
+    this.username = username;
+    this._patches = [];
+  }
+  get patches() {
+    return this._patches;
+  }
+  initThread(thread, debounceMs = 2e3) {
+    console.log("InitPatchInstance with thread", thread);
+    this.thread = thread;
+    this.sync = debouncePromise(_Patches.prototype.sync.bind(this), debounceMs);
+    if (this._patches.length > 0) {
+      this.sync().catch(console.error);
+    }
+  }
+  get threadInstance() {
+    return this.thread;
+  }
+  static onSync(callback) {
+    this.onSyncListeners.push(callback);
+  }
+  static setReplay(replay) {
+    this._replaying = replay;
+  }
+  /** Drops all queued (not yet persisted) patches. Test/reset helper. */
+  clearQueue() {
+    this._patches = [];
+  }
+  addPatch(op) {
+    if (_Patches._replaying) {
+      return;
+    }
+    if (isEvmPatch(op)) {
+      if (op.operation === PatchOperation.EditPropertyString) {
+        op.value = sanitizeText(op.value);
+      } else if (op.operation === PatchOperation.EditInstanceFieldString) {
+        op.value = sanitizeText(op.value);
+      }
+    }
+    this._patches.push(op);
+    this.sync().catch(console.error);
+  }
+  /**
+   * Last-Writer-Wins consolidation. Walks the queue from the newest entry
+   * backwards and keeps only the latest edit per logical slot.
+   *
+   * The sub-key for property edits incorporates the language code
+   * (`${propertyId}:${langId ?? 0}`) so a French string edit never erases
+   * a previous English edit (SPEC §2.2). Instance field edits additionally
+   * key on the instance index.
+   */
+  static cleanData(data) {
+    const dataIndex = {};
+    const isUndefined = (obj) => typeof obj === "undefined";
+    const filteredData = [];
+    const keep = (key, subKey, item) => {
+      if (isUndefined(dataIndex[key])) {
+        dataIndex[key] = {};
+      }
+      if (isUndefined(dataIndex[key][subKey])) {
+        dataIndex[key][subKey] = true;
+        filteredData.push(item);
+      }
+    };
+    const keepOldest = (key, subKey, item) => {
+      if (isUndefined(dataIndex[key])) {
+        dataIndex[key] = {};
+      }
+      if (isUndefined(dataIndex[key][subKey])) {
+        dataIndex[key][subKey] = filteredData.length;
+        filteredData.push(item);
+      } else {
+        filteredData[dataIndex[key][subKey]] = item;
+      }
+    };
+    for (let i = data.length - 1; i >= 0; i--) {
+      const item = data[i];
+      if (isEvmPatch(item)) {
+        const key2 = `evm-${item.objectType}-${item.objectId ?? item.fromUid}-${item.operation}`;
+        switch (item.operation) {
+          case PatchOperation.EditPropertyString:
+          case PatchOperation.EditPropertyNumber: {
+            const d = item;
+            keep(key2, `${d.propertyId}:${d.langId ?? 0}`, item);
+            break;
+          }
+          case PatchOperation.EditInstanceFieldString:
+          case PatchOperation.EditInstanceFieldNumber: {
+            const d = item;
+            keep(key2, `${d.instanceIndex}:${d.propertyId}:${d.langId ?? 0}`, item);
+            break;
+          }
+          case PatchOperation.EditRelation: {
+            const d = item;
+            keep(key2, `${d.relationId}:${d.targetId}`, item);
+            break;
+          }
+          case PatchOperation.SetAlias: {
+            const d = item;
+            keep(key2, `${d.fromUid}`, item);
+            break;
+          }
+          case PatchOperation.CreateRecord: {
+            keep(key2, "create", item);
+            break;
+          }
+          case PatchOperation.AddInstance: {
+            const d = item;
+            keepOldest(key2, `${d.langId ?? 0}:${d.instanceIndex}`, item);
+            break;
+          }
+          default:
+            throw new Error(`unknown patch operation ${item.operation}`);
+        }
+        continue;
+      }
+      const op = item;
+      const key = `local-${op.objectType}-${op.objectId}-${op.action}`;
+      switch (op.action) {
+        case 4 /* RatePart */:
+          keep(key, `${op.part}`, op);
+          break;
+        case 6 /* SharePart */:
+          keep(key, `${op.part}:${op.socialMediaId}`, op);
+          break;
+        case 3 /* Rate */:
+          keep(key, "seen", op);
+          break;
+        case 0 /* Visit */:
+        case 2 /* Download */:
+        case 5 /* Share */:
+        case 1 /* VisitPart */:
+          filteredData.push(op);
+          break;
+        default:
+          throw new Error(`unknown local action ${op.action}`);
+      }
+    }
+    filteredData.reverse();
+    return filteredData;
+  }
+  /**
+   * Syncs the queued patches to the worker (IndexedDB persistence).
+   * Before initThread, patches are retained in the queue (never dropped);
+   * initThread flushes them as soon as the worker is available.
+   */
+  async sync() {
+    if (typeof this.thread === "undefined") {
+      return null;
+    }
+    const data = _Patches.cleanData([...this._patches]);
+    if (data.length === 0) {
+      this._patches = [];
+      return true;
+    }
+    this._patches = [];
+    _Patches.onSyncListeners.forEach((cb) => {
+      try {
+        cb(data);
+      } catch (e) {
+        console.error(e);
+      }
+    });
+    let savePatchOperation;
+    try {
+      savePatchOperation = await this.thread.sendRequest({
+        cmd: "savePatches" /* SavePatches */,
+        payload: {
+          username: this.username,
+          patches: data
+        }
+      });
+    } catch (err) {
+      this._patches.unshift(...data);
+      throw err;
+    }
+    const level = await _Patches.calculateLevel(this.username);
+    console.log("level after saving patches", level);
+    return savePatchOperation;
+  }
+  static async calculateLevel(username) {
+    const patches = await getAllPatchesByUsername(username);
+    const cleaned = this.cleanData(patches);
+    let score = 0;
+    for (const p of cleaned) {
+      if (isEvmPatch(p)) {
+        switch (p.operation) {
+          case PatchOperation.EditPropertyString:
+          case PatchOperation.EditInstanceFieldString:
+            score += 4;
+            break;
+          case PatchOperation.EditPropertyNumber:
+          case PatchOperation.EditInstanceFieldNumber:
+            score += 2;
+            break;
+          case PatchOperation.EditRelation:
+            score += 3;
+            break;
+          case PatchOperation.SetAlias:
+            score += 5;
+            break;
+        }
+        continue;
+      }
+      switch (p.action) {
+        case 1 /* VisitPart */:
+          score += 0.5;
+          break;
+        case 6 /* SharePart */:
+          score += 1;
+          break;
+        case 4 /* RatePart */:
+          score += 1;
+          break;
+        case 3 /* Rate */:
+          score += 1;
+          break;
+        case 0 /* Visit */:
+          score += 1;
+          break;
+        case 5 /* Share */:
+          score += 2;
+          break;
+        case 2 /* Download */:
+          score += 3;
+          break;
+      }
+    }
+    const level = score / 7;
+    if (typeof window !== "undefined" && typeof CustomEvent !== "undefined") {
+      const evt = new CustomEvent("LevelUpdate", {
+        detail: { level, username },
+        bubbles: true
+      });
+      window.dispatchEvent(evt);
+    }
+    return level;
+  }
+};
+_Patches._replaying = false;
+_Patches.onSyncListeners = [];
+var Patches = _Patches;
+var patchesMap = /* @__PURE__ */ new Map();
+var PatchInstance = new Patches("mine");
+patchesMap.set("mine", PatchInstance);
+var deserializePatches = async (username, payload) => {
+  const operations = evmToPatch(payload, versionsFile);
+  console.log(`[Patches] deserializePatches: writing ${operations.length} restored patches for ${username}`);
+  await bulkAddPatches(username, operations);
+};
+var serializePatches = async (fromIndex, toIndex) => {
+  const stored = await getAllPatchesSince("mine", fromIndex);
+  const evmPatches = stored.slice(0, toIndex - fromIndex).filter(isEvmPatch).map(({ pk, username, ...op }) => op).map((op) => {
+    if (op.operation === PatchOperation.EditPropertyString) {
+      op.value = sanitizeText(op.value);
+    } else if (op.operation === PatchOperation.EditInstanceFieldString) {
+      op.value = sanitizeText(op.value);
+    }
+    return op;
+  });
+  return patchToEvm(evmPatches, currentLayout(), CURRENT_VERSION);
+};
+var getPatchInstanceByAccount = (account) => {
+  if (!patchesMap.has(account)) {
+    console.warn(`Account ${account} does not exist in patchesInstances \u2014 creating a new one`);
+    const p = new Patches(account);
+    p.initThread(PatchInstance.threadInstance);
+    patchesMap.set(account, p);
+  }
+  return patchesMap.get(account);
+};
+
+// src/models/stats.ts
+var StatsStore = /* @__PURE__ */ new Map();
+var check = (objectType, objectId) => {
+  if (!StatsStore.has(objectType)) {
+    StatsStore.set(objectType, /* @__PURE__ */ new Map());
+  }
+  if (!StatsStore.get(objectType).has(objectId)) {
+    StatsStore.get(objectType).set(objectId, {
+      visits: [],
+      downloads: [],
+      rating: 0 /* None */,
+      socialMediaId: [],
+      parts: {}
+    });
+  }
+};
+var PopulateStatsStore = (operations) => {
+  for (const op of operations) {
+    check(op.objectType, op.objectId);
+    const map = StatsStore.get(op.objectType);
+    const stats = map.get(op.objectId);
+    switch (op.action) {
+      case 0 /* Visit */:
+        stats.visits.push(DateUtils.now());
+        break;
+      case 2 /* Download */:
+        stats.downloads.push(DateUtils.now());
+        break;
+      case 1 /* VisitPart */:
+        if (stats.parts[op.part]) {
+          stats.parts[op.part].visits.push(DateUtils.now());
+        } else {
+          stats.parts[op.part] = {
+            rating: 0 /* None */,
+            visits: [DateUtils.now()],
+            socialMediaId: []
+          };
+        }
+        break;
+      case 4 /* RatePart */:
+        if (stats.parts[op.part]) {
+          stats.parts[op.part].rating = op.rate;
+        } else {
+          stats.parts[op.part] = {
+            rating: op.rate,
+            visits: [],
+            socialMediaId: []
+          };
+        }
+        break;
+      case 3 /* Rate */:
+        stats.rating = op.rate;
+        break;
+      case 6 /* SharePart */:
+        if (stats.parts[op.part]) {
+          stats.parts[op.part].socialMediaId.push(op.socialMediaId);
+        } else {
+          stats.parts[op.part] = {
+            rating: 0 /* None */,
+            visits: [],
+            socialMediaId: [op.socialMediaId]
+          };
+        }
+        break;
+      case 5 /* Share */:
+        stats.socialMediaId.push(op.socialMediaId);
+        break;
+      default:
+        break;
+    }
+  }
+};
+var DownloadsByType = (objectType) => {
+  if (!StatsStore.has(objectType)) {
+    return [];
+  }
+  const map = StatsStore.get(objectType);
+  return Array.from(map.entries()).filter(([, value]) => value.downloads.length > 0).map(([k]) => k);
+};
+var VisitsByType = (objectType) => {
+  if (!StatsStore.has(objectType)) {
+    return [];
+  }
+  const map = StatsStore.get(objectType);
+  return Array.from(map.entries()).filter(([, value]) => value.visits.length > 0).map(([k]) => k);
+};
+var FavoritesByTypes = (objectType) => {
+  if (!StatsStore.has(objectType)) {
+    return [];
+  }
+  const map = StatsStore.get(objectType);
+  const result = Array.from(map.keys()).filter((id) => {
+    const summary = map.get(id);
+    return summary.visits.length > 0 || summary.downloads.length > 0 || [2 /* Keep */, 1 /* New */, 4 /* Shared */].includes(summary.rating);
+  }).map((id) => {
+    const summary = map.get(id);
+    return { id, nbVisits: summary.visits.length, rating: summary.rating };
+  });
+  result.sort((a, b) => b.nbVisits - a.nbVisits);
+  return result;
+};
+var Stats = class {
+  constructor(objectId, objectType) {
+    this.objectId = objectId;
+    this.objectType = objectType;
+  }
+  favoriteParts() {
+    if (!StatsStore.has(this.objectType)) {
+      return [];
+    }
+    const map = StatsStore.get(this.objectType);
+    if (!map.has(this.objectId)) {
+      return [];
+    }
+    const summary = map.get(this.objectId);
+    const result = Object.keys(summary.parts).map((partId) => {
+      return {
+        partId: parseInt(partId),
+        nbVisits: summary.parts[partId].visits.length,
+        rating: summary.parts[partId].rating
+      };
+    });
+    result.sort((a, b) => b.nbVisits - a.nbVisits);
+    return result;
+  }
+  check() {
+    check(this.objectType, this.objectId);
+  }
+  visit() {
+    const op = {
+      action: 0 /* Visit */,
+      ts: DateUtils.now(),
+      objectId: this.objectId,
+      objectType: this.objectType
+    };
+    PopulateStatsStore([op]);
+    PatchInstance.addPatch(op);
+  }
+  download() {
+    const op = {
+      objectType: this.objectType,
+      objectId: this.objectId,
+      ts: DateUtils.now(),
+      action: 2 /* Download */
+    };
+    PopulateStatsStore([op]);
+    PatchInstance.addPatch(op);
+  }
+  get rating() {
+    this.check();
+    return StatsStore.get(this.objectType)?.get(this.objectId)?.rating;
+  }
+  set rating(rating) {
+    const op = {
+      objectType: this.objectType,
+      objectId: this.objectId,
+      ts: DateUtils.now(),
+      action: 3 /* Rate */,
+      rate: rating
+    };
+    PopulateStatsStore([op]);
+    PatchInstance.addPatch(op);
+  }
+  share(socialMediaId) {
+    const op = {
+      objectType: this.objectType,
+      objectId: this.objectId,
+      ts: DateUtils.now(),
+      action: 5 /* Share */,
+      socialMediaId
+    };
+    PopulateStatsStore([op]);
+    PatchInstance.addPatch(op);
+  }
+  ratePart(partId, rating) {
+    const op = {
+      objectType: this.objectType,
+      objectId: this.objectId,
+      ts: DateUtils.now(),
+      action: 4 /* RatePart */,
+      part: partId,
+      rate: rating
+    };
+    PopulateStatsStore([op]);
+    PatchInstance.addPatch(op);
+  }
+  visitPart(partId) {
+    const op = {
+      objectType: this.objectType,
+      objectId: this.objectId,
+      ts: DateUtils.now(),
+      action: 1 /* VisitPart */,
+      part: partId
+    };
+    PopulateStatsStore([op]);
+    PatchInstance.addPatch(op);
+  }
+};
+
+// src/models/versioning.ts
+var versioning = /* @__PURE__ */ new Map();
+var currentUsername = "mine";
+var collectionFor = (objectType, objectId) => {
+  if (!versioning.has(objectType)) {
+    versioning.set(objectType, /* @__PURE__ */ new Map());
+  }
+  const collection = versioning.get(objectType);
+  if (!collection.has(objectId)) {
+    collection.set(objectId, {
+      createdBy: currentUsername,
+      properties: /* @__PURE__ */ new Map(),
+      relations: /* @__PURE__ */ new Map()
+    });
+  }
+  return collection.get(objectId);
+};
+var track = (patch) => {
+  if (Patches._replaying) {
+    return;
+  }
+  switch (patch.operation) {
+    case PatchOperation.EditPropertyString:
+    case PatchOperation.EditPropertyNumber: {
+      const op = patch;
+      const entry = collectionFor(op.objectType, op.objectId);
+      if (!entry.properties.has(op.propertyId)) {
+        entry.properties.set(op.propertyId, []);
+      }
+      entry.properties.get(op.propertyId).push({
+        username: currentUsername,
+        value: op.value,
+        langId: op.langId
+      });
+      break;
+    }
+    case PatchOperation.EditRelation: {
+      const op = patch;
+      const entry = collectionFor(op.objectType, op.objectId);
+      if (!entry.relations.has(op.relationId)) {
+        entry.relations.set(op.relationId, []);
+      }
+      entry.relations.get(op.relationId).push({
+        username: currentUsername,
+        value: [op.action === PatchAction.Add ? "+" : "-", op.targetId]
+      });
+      break;
+    }
+    default:
+      break;
+  }
+};
+
+// src/models/uidFactory.ts
+function isUserCreated(wireId) {
+  return (wireId >>> 0 & 2147483648) !== 0;
+}
+
+// src/models/db.ts
+var systems = /* @__PURE__ */ new Set();
+function addReactivitySystem(sys) {
+  systems.add(sys);
+  return () => {
+    systems.delete(sys);
+  };
+}
+function setReactivitySystem(sys) {
+  systems.clear();
+  if (sys) systems.add(sys);
+}
+var dbReactivity = {
+  track(obj) {
+    for (const s of systems) s.track(obj);
+  },
+  trigger(obj) {
+    for (const s of systems) s.trigger(obj);
+  }
+};
+var LruCache = class {
+  constructor(limit) {
+    this.limit = limit;
+    this.map = /* @__PURE__ */ new Map();
+    this._pinned = /* @__PURE__ */ new Set();
+    this._warnedOverflow = false;
+  }
+  get size() {
+    return this.map.size;
+  }
+  get(key) {
+    if (!this.map.has(key)) return void 0;
+    const val = this.map.get(key);
+    this.map.delete(key);
+    this.map.set(key, val);
+    return val;
+  }
+  set(key, val) {
+    if (this.map.has(key)) {
+      this.map.delete(key);
+    }
+    this.map.set(key, val);
+    if (this.map.size > this.limit) {
+      let evicted = false;
+      for (const k of this.map.keys()) {
+        if (!this._pinned.has(k)) {
+          this.map.delete(k);
+          evicted = true;
+          break;
+        }
+      }
+      if (!evicted && !this._warnedOverflow) {
+        this._warnedOverflow = true;
+        console.warn(
+          `[LruCache] limit (${this.limit}) exceeded with every entry pinned \u2014 growing past limit instead of evicting/crashing. This usually means too many draft/unsynced records are open at once.`
+        );
+      }
+    }
+  }
+  pin(key) {
+    this._pinned.add(key);
+  }
+  unpin(key) {
+    this._pinned.delete(key);
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+  delete(key) {
+    this.map.delete(key);
+  }
+  clear() {
+    this.map.clear();
+  }
+  keys() {
+    return this.map.keys();
+  }
+  values() {
+    return this.map.values();
+  }
+};
+var DEFAULT_CACHE_LIMIT = 1e4;
+var dbConfig = {
+  cacheLimit: DEFAULT_CACHE_LIMIT
+};
+var memory = /* @__PURE__ */ new Map();
+var configureDb = (opts) => {
+  if (opts.cacheLimit && opts.cacheLimit > 0) {
+    dbConfig.cacheLimit = opts.cacheLimit;
+    for (const cache of memory.values()) {
+      cache.limit = opts.cacheLimit;
+    }
+  }
+};
+var cacheFor = (objectType) => {
+  let cache = memory.get(objectType);
+  if (!cache) {
+    cache = new LruCache(dbConfig.cacheLimit);
+    memory.set(objectType, cache);
+  }
+  return cache;
+};
+var clear = () => {
+  memory.clear();
+};
+var dump = () => {
+  return memory;
+};
+function getRecordKey(wireId, creatorUsername) {
+  if (isUserCreated(wireId)) {
+    if (!creatorUsername) throw new Error("[models_v2] creatorUsername required for user-created records");
+    return `${creatorUsername}:${wireId}`;
+  }
+  return `canonical:${wireId}`;
+}
+var hasRecord = (objectType, id, creatorUsername) => {
+  if (isUserCreated(id) && !creatorUsername) return false;
+  return cacheFor(objectType).has(getRecordKey(id, creatorUsername));
+};
+var getRecord = (objectType, id, creatorUsername) => {
+  const key = getRecordKey(id, creatorUsername);
+  const record = cacheFor(objectType).get(key);
+  if (typeof record === "undefined") {
+    throw new Error(`cannot find ${objectType} with id ${id} (evicted or never loaded \u2014 use LoadAsync)`);
+  }
+  return record;
+};
+var addRecord = (objectType, obj, creatorUsername) => {
+  cacheFor(objectType).set(getRecordKey(obj.id, creatorUsername), obj);
+};
+var removeRecord = (objectType, id, creatorUsername) => {
+  cacheFor(objectType).delete(getRecordKey(id, creatorUsername));
+};
+var pinRecord = (objectType, id, creatorUsername) => {
+  cacheFor(objectType).pin(getRecordKey(id, creatorUsername));
+};
+var unpinRecord = (objectType, id, creatorUsername) => {
+  cacheFor(objectType).unpin(getRecordKey(id, creatorUsername));
+};
+
+// src/models/localRecordTable.ts
+var LocalRecordTable = class {
+  constructor() {
+    this.db = null;
+    this.instanceRemaps = new IDBInstanceRemapStore(this);
+  }
+  /** Called once at app startup, before any createNew() call — mirrors PatchInstance.initThread(). */
+  init(db) {
+    this.db = db;
+  }
+  get idb() {
+    if (!this.db) throw new Error("[models_v2] LocalRecordTable not initialised \u2014 call localRecordTable.init(db) at startup");
+    return this.db;
+  }
+  async put(entry) {
+    return new Promise((resolve, reject) => {
+      const tx = this.idb.transaction("localRecords", "readwrite");
+      const store = tx.objectStore("localRecords");
+      const req = store.put(entry);
+      req.onsuccess = () => resolve();
+      req.onerror = () => reject(req.error);
+    });
+  }
+  async putIfAbsent(entry) {
+    return new Promise((resolve, reject) => {
+      const tx = this.idb.transaction("localRecords", "readwrite");
+      tx.onabort = () => reject(tx.error || new Error("Transaction aborted"));
+      tx.onerror = () => reject(tx.error);
+      const store = tx.objectStore("localRecords");
+      const getReq = store.get([entry.creatorUsername, entry.wireId]);
+      getReq.onsuccess = () => {
+        if (!getReq.result) {
+          const addReq = store.add(entry);
+          addReq.onsuccess = () => resolve();
+          addReq.onerror = () => reject(addReq.error);
+        } else {
+          resolve();
+        }
+      };
+      getReq.onerror = () => reject(getReq.error);
+    });
+  }
+  async get(creatorUsername, wireId) {
+    return new Promise((resolve, reject) => {
+      const tx = this.idb.transaction("localRecords", "readonly");
+      const store = tx.objectStore("localRecords");
+      const req = store.get([creatorUsername, wireId]);
+      req.onsuccess = () => resolve(req.result);
+      req.onerror = () => reject(req.error);
+    });
+  }
+  async getByCreator(creatorUsername) {
+    return new Promise((resolve, reject) => {
+      const tx = this.idb.transaction("localRecords", "readonly");
+      const store = tx.objectStore("localRecords");
+      const index = store.index("byCreator");
+      const req = index.getAll(creatorUsername);
+      req.onsuccess = () => resolve(req.result);
+      req.onerror = () => reject(req.error);
+    });
+  }
+  async setStatus(creatorUsername, wireId, status) {
+    return new Promise((resolve, reject) => {
+      const tx = this.idb.transaction("localRecords", "readwrite");
+      const store = tx.objectStore("localRecords");
+      const getReq = store.get([creatorUsername, wireId]);
+      getReq.onsuccess = () => {
+        if (!getReq.result) {
+          reject(new Error(`LocalRecordEntry not found: ${creatorUsername}:${wireId}`));
+          return;
+        }
+        const entry = getReq.result;
+        entry.status = status;
+        const putReq = store.put(entry);
+        putReq.onsuccess = () => resolve();
+        putReq.onerror = () => reject(putReq.error);
+      };
+      getReq.onerror = () => reject(getReq.error);
+    });
+  }
+  async setCanonicalId(creatorUsername, wireId, canonicalId) {
+    return new Promise((resolve, reject) => {
+      const tx = this.idb.transaction("localRecords", "readwrite");
+      const store = tx.objectStore("localRecords");
+      const getReq = store.get([creatorUsername, wireId]);
+      getReq.onsuccess = () => {
+        if (!getReq.result) {
+          reject(new Error(`LocalRecordEntry not found: ${creatorUsername}:${wireId}`));
+          return;
+        }
+        const entry = getReq.result;
+        entry.canonicalId = canonicalId;
+        const putReq = store.put(entry);
+        putReq.onsuccess = () => resolve();
+        putReq.onerror = () => reject(putReq.error);
+      };
+      getReq.onerror = () => reject(getReq.error);
+    });
+  }
+};
+var IDBInstanceRemapStore = class {
+  constructor(table) {
+    this.table = table;
+  }
+  async get(objectId, langId, creatorUsername, originalIndex) {
+    return new Promise((resolve, reject) => {
+      const db = this.table.idb;
+      const tx = db.transaction(instanceRemapsStoreName, "readonly");
+      const store = tx.objectStore(instanceRemapsStoreName);
+      const req = store.get([creatorUsername, objectId, langId, originalIndex]);
+      req.onsuccess = () => resolve(req.result?.realIndex);
+      req.onerror = () => reject(req.error);
+    });
+  }
+  async put(objectId, langId, creatorUsername, originalIndex, realIndex) {
+    return new Promise((resolve, reject) => {
+      const db = this.table.idb;
+      const tx = db.transaction(instanceRemapsStoreName, "readwrite");
+      const store = tx.objectStore(instanceRemapsStoreName);
+      const req = store.put({ creatorUsername, objectId, langId, originalIndex, realIndex });
+      req.onsuccess = () => resolve();
+      req.onerror = () => reject(req.error);
+    });
+  }
+};
+var localRecordTable = new LocalRecordTable();
+
+// src/models/enriched-index.ts
+var SIDECAR_MAGIC = 1146113329;
+var SIDECAR_FORMAT_VERSION = 2;
+var columnTypeForBits = (bits) => {
+  if (bits <= 0) return 3 /* NullableString */;
+  if (bits <= 8) return 1 /* Uint8 */;
+  if (bits <= 16) return 2 /* Uint16 */;
+  return 6 /* Uint32 */;
+};
+var instanceSpecFromFields = (fields, fieldLayouts) => {
+  return fields.map((f, idx) => {
+    if (f.type === "string") return { name: f.name, type: 3 /* NullableString */ };
+    if (f.type === "boolean") return { name: f.name, type: 7 /* Bool */ };
+    const bits = fieldLayouts?.[idx]?.bits ?? f.bits ?? 32;
+    return { name: f.name, type: columnTypeForBits(bits) };
+  });
+};
+var IS_DEFAULT_SPEC = { name: "isDefault", type: 7 /* Bool */ };
+var textDecoder = new TextDecoder();
+var textEncoder = new TextEncoder();
+var extractRecordCols = (parsed, index) => {
+  const sliceCol = (data) => Array.isArray(data) ? [data[index] ?? null] : data.slice(index, index + 1);
+  if (parsed.header.sidecarType === 2 /* Provenance */) {
+    const fields = {};
+    let ids;
+    for (const [name, data] of parsed.columns) {
+      if (name === "ids") ids = sliceCol(data);
+      else fields[name] = sliceCol(data);
+    }
+    return { ids, fields };
+  }
+  const cols = {};
+  for (const [name, data] of parsed.columns) {
+    cols[name] = sliceCol(data);
+  }
+  if (parsed.relations) for (const [name, data] of parsed.relations) cols[name] = [data[index] ?? []];
+  if (parsed.authorIds) cols["authorIds"] = [parsed.authorIds[index] ?? []];
+  if (parsed.instances) cols["instances"] = [parsed.instances[index] ?? []];
+  return cols;
+};
+var Writer = class {
+  constructor() {
+    this.chunks = [];
+  }
+  u8(v) {
+    this.chunks.push(new Uint8Array([v & 255]));
+  }
+  u16(v) {
+    const b = new Uint8Array(2);
+    new DataView(b.buffer).setUint16(0, v);
+    this.chunks.push(b);
+  }
+  u24(v) {
+    const b = new Uint8Array(3);
+    b[0] = v >>> 16 & 255;
+    b[1] = v >>> 8 & 255;
+    b[2] = v & 255;
+    this.chunks.push(b);
+  }
+  u32(v) {
+    const b = new Uint8Array(4);
+    new DataView(b.buffer).setUint32(0, v >>> 0);
+    this.chunks.push(b);
+  }
+  bytes(v) {
+    this.chunks.push(v);
+  }
+  nullableString(v) {
+    if (v === null) {
+      this.u8(0);
+      return;
+    }
+    this.u8(1);
+    const encoded = textEncoder.encode(v);
+    this.u16(encoded.length);
+    this.bytes(encoded);
+  }
+  toBuffer() {
+    const total = this.chunks.reduce((acc, c) => acc + c.length, 0);
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const c of this.chunks) {
+      out.set(c, offset);
+      offset += c.length;
+    }
+    return out.buffer;
+  }
+};
+var collectRelations = (input) => {
+  const list = [...input.relations ?? []];
+  if (input.authorIds && !list.some((r) => r.name === "authors")) {
+    list.push({ name: "authors", data: input.authorIds });
+  }
+  return list;
+};
+var writeFieldValue = (w, type, value) => {
+  switch (type) {
+    case 1 /* Uint8 */:
+      w.u8(value ?? 0);
+      break;
+    case 2 /* Uint16 */:
+      w.u16(value ?? 0);
+      break;
+    case 6 /* Uint32 */:
+      w.u32(value ?? 0);
+      break;
+    case 7 /* Bool */:
+      w.u8(value ? 1 : 0);
+      break;
+    case 3 /* NullableString */:
+      w.nullableString(value ?? null);
+      break;
+    default:
+      throw new Error(`Unsupported instance field type 0x${type.toString(16)}`);
+  }
+};
+var writeInstanceDescriptor = (w, spec) => {
+  if (spec.length > 255) throw new Error("Too many instance fields (max 255)");
+  w.u8(spec.length);
+  for (const field of spec) {
+    w.u8(field.type);
+    const nameBytes = textEncoder.encode(field.name);
+    w.u8(nameBytes.length);
+    w.bytes(nameBytes);
+  }
+};
+var writeSidecar = (input) => {
+  const w = new Writer();
+  w.u32(SIDECAR_MAGIC);
+  w.u8(SIDECAR_FORMAT_VERSION);
+  w.u24(input.recordCount);
+  w.u8(input.columns.length);
+  w.u8(input.sidecarType);
+  for (const col of input.columns) {
+    w.u8(col.type);
+    const nameBytes = textEncoder.encode(col.name);
+    w.u8(nameBytes.length);
+    w.bytes(nameBytes);
+    const data = col.data;
+    for (let i = 0; i < input.recordCount; i++) {
+      switch (col.type) {
+        case 1 /* Uint8 */:
+          w.u8(data[i] ?? 0);
+          break;
+        case 2 /* Uint16 */:
+          w.u16(data[i] ?? 0);
+          break;
+        case 6 /* Uint32 */:
+          w.u32(data[i] ?? 0);
+          break;
+        case 7 /* Bool */:
+          w.u8(data[i] ? 1 : 0);
+          break;
+        case 3 /* NullableString */:
+          w.nullableString(data[i] ?? null);
+          break;
+        default:
+          throw new Error(`Unsupported column type 0x${col.type.toString(16)}`);
+      }
+    }
+  }
+  if (input.sidecarType === 1 /* Extended */) {
+    const relations = collectRelations(input);
+    w.u8(relations.length);
+    for (const rel of relations) {
+      const nameBytes = textEncoder.encode(rel.name);
+      w.u8(nameBytes.length);
+      w.bytes(nameBytes);
+    }
+    for (let i = 0; i < input.recordCount; i++) {
+      for (const rel of relations) {
+        const uids = rel.data[i] ?? [];
+        w.u16(uids.length);
+        for (const u of uids) w.u24(u);
+      }
+    }
+    const declared = input.instanceFields ?? [];
+    if ((input.instances?.length ?? 0) > 0 && declared.length === 0) {
+      throw new Error("writeSidecar: instances provided without instanceFields spec");
+    }
+    const spec = declared.some((f) => f.name === IS_DEFAULT_SPEC.name) ? declared : [...declared, IS_DEFAULT_SPEC];
+    writeInstanceDescriptor(w, spec);
+    const instances = input.instances ?? [];
+    for (let i = 0; i < input.recordCount; i++) {
+      const list = instances[i] ?? [];
+      w.u16(list.length);
+      for (const inst of list) {
+        for (const field of spec) {
+          writeFieldValue(w, field.type, inst[field.name]);
+        }
+      }
+    }
+  }
+  return w.toBuffer();
+};
+
+// src/models/serializer.ts
+var capitalize = (name) => name.charAt(0).toUpperCase() + name.slice(1);
+var colName = (name, type) => type === "string" && !name.endsWith("s") ? `${name}s` : name;
+var propBits = (prop, layout) => {
+  const fromLayout = layout.props[prop.propId]?.bits;
+  if (typeof fromLayout === "number" && fromLayout > 0) return fromLayout;
+  if (prop.type === "boolean") return 1;
+  return prop.bits ?? 32;
+};
+var instanceFieldBits = (field, index, objectId, layout) => {
+  const propId = layout.instanceFields?.[objectId]?.[index];
+  const fromLayout = typeof propId === "number" ? layout.props[propId]?.bits : void 0;
+  if (typeof fromLayout === "number" && fromLayout > 0) return fromLayout;
+  if (field.type === "boolean") return 1;
+  return field.bits ?? 32;
+};
+var relationColName = (rel) => rel.name === "authors" ? "authorIds" : rel.name;
+var extractTypedArray = (bits, values) => {
+  if (bits <= 8) return Uint8Array.from(values);
+  if (bits <= 16) return Uint16Array.from(values);
+  return Uint32Array.from(values);
+};
+function commonSerializeSlim(schema4, records, layout) {
+  const uids = records.map((r) => r.id);
+  const columns = [
+    { name: "ids", type: 6 /* Uint32 */, data: Uint32Array.from(uids) },
+    { name: "titles", type: 3 /* NullableString */, data: records.map((r) => r.title) },
+    { name: "originalLangs", type: 3 /* NullableString */, data: records.map((r) => r.originalLang) },
+    { name: "previewTxIds", type: 3 /* NullableString */, data: records.map((r) => r.previewTxId) },
+    { name: "ageGradeBands", type: 1 /* Uint8 */, data: Uint8Array.from(records.map((r) => r.ageGradeBand)) },
+    { name: "safes", type: 1 /* Uint8 */, data: Uint8Array.from(records.map((r) => r.safe ? 1 : 0)) },
+    { name: "deleteds", type: 1 /* Uint8 */, data: Uint8Array.from(records.map((r) => r.deleted ? 1 : 0)) }
+  ];
+  for (const prop of schema4.props.filter((p) => p.source === "slim")) {
+    const name = colName(prop.name, prop.type);
+    if (prop.type === "string") {
+      columns.push({ name, type: 3 /* NullableString */, data: records.map((r) => r[prop.name]) });
+    } else if (prop.type === "boolean") {
+      columns.push({ name, type: 1 /* Uint8 */, data: Uint8Array.from(records.map((r) => r[prop.name] ? 1 : 0)) });
+    } else {
+      const bits = propBits(prop, layout);
+      columns.push({ name, type: columnTypeForBits(bits), data: extractTypedArray(bits, records.map((r) => r[prop.name])) });
+    }
+  }
+  if (schema4.multipleInstances) {
+    for (let i = 0; i < schema4.instanceFields.length; i++) {
+      const field = schema4.instanceFields[i];
+      const capField = capitalize(field.name);
+      const capName = colName(capField, field.type);
+      const values = records.map((r) => r[`default${capField}`]);
+      if (field.type === "string") {
+        columns.push({ name: `default${capName}`, type: 3 /* NullableString */, data: values });
+      } else if (field.type === "boolean") {
+        columns.push({ name: `default${capName}`, type: 1 /* Uint8 */, data: Uint8Array.from(values.map((v) => v ? 1 : 0)) });
+      } else {
+        const bits = instanceFieldBits(field, i, schema4.objectId, layout);
+        columns.push({ name: `default${capName}`, type: columnTypeForBits(bits), data: extractTypedArray(bits, values) });
+      }
+    }
+  }
+  const input = {
+    sidecarType: 0 /* Slim */,
+    recordCount: records.length,
+    columns
+  };
+  return writeSidecar(input);
+}
+function commonSerializeExtended(schema4, records, layout) {
+  const uids = records.map((r) => r.id);
+  const columns = [
+    { name: "ids", type: 6 /* Uint32 */, data: Uint32Array.from(uids) },
+    { name: "descriptions", type: 3 /* NullableString */, data: records.map((r) => r.description) }
+  ];
+  for (const prop of schema4.props.filter((p) => p.source === "extended")) {
+    const name = colName(prop.name, prop.type);
+    if (prop.type === "string") {
+      columns.push({ name, type: 3 /* NullableString */, data: records.map((r) => r[prop.name]) });
+    } else if (prop.type === "boolean") {
+      columns.push({ name, type: 1 /* Uint8 */, data: Uint8Array.from(records.map((r) => r[prop.name] ? 1 : 0)) });
+    } else {
+      const bits = propBits(prop, layout);
+      columns.push({ name, type: columnTypeForBits(bits), data: extractTypedArray(bits, records.map((r) => r[prop.name])) });
+    }
+  }
+  const hasRelations = schema4.relations.filter((r) => r.direction === "has");
+  const relations = hasRelations.map((rel) => ({
+    name: rel.name,
+    data: records.map((r) => r[relationColName(rel)])
+  }));
+  const input = {
+    sidecarType: 1 /* Extended */,
+    recordCount: records.length,
+    columns,
+    ...relations.length > 0 && { relations }
+  };
+  if (schema4.multipleInstances) {
+    input.instanceFields = instanceSpecFromFields(schema4.instanceFields);
+    input.instances = records.map((r) => r.instances);
+  }
+  return writeSidecar(input);
+}
+function commonSerializeProv(schema4, records) {
+  const input = {
+    sidecarType: 2 /* Provenance */,
+    recordCount: records.length,
+    columns: [
+      { name: "ids", type: 6 /* Uint32 */, data: Uint32Array.from(records.map((r) => r.id)) }
+    ]
+  };
+  return writeSidecar(input);
+}
+
+// src/models/registry.ts
+var relationColName2 = (rel) => rel.name === "authors" ? "authorIds" : rel.name;
+var SchemaRegistry = class _SchemaRegistry {
+  constructor() {
+    this.schemas = /* @__PURE__ */ new Map();
+    this.byName = /* @__PURE__ */ new Map();
+  }
+  static getInstance() {
+    if (!_SchemaRegistry.instance) {
+      _SchemaRegistry.instance = new _SchemaRegistry();
+    }
+    return _SchemaRegistry.instance;
+  }
+  register(schema4) {
+    this.schemas.set(schema4.objectId, schema4);
+    this.byName.set(schema4.name, schema4);
+  }
+  get(id) {
+    const schema4 = this.schemas.get(id);
+    if (!schema4) {
+      console.warn(`[SchemaRegistry] No schema registered for type ID ${id}. Returning generic placeholder.`);
+      return { name: "Generic", typePrefix: "XX", objectId: id, multipleInstances: false, props: [], instanceFields: [], relations: [] };
+    }
+    return schema4;
+  }
+  /** Lookup by model name (relation targetType resolution). */
+  getByName(name) {
+    return this.byName.get(name);
+  }
+  clear() {
+    this.schemas.clear();
+    this.byName.clear();
+  }
+};
+var Registry = SchemaRegistry.getInstance();
+
+// src/models/orm.ts
+var _userLang = null;
+var _commonLang = "eng";
+var _defaultProvenance = void 0;
+var Config = {
+  get userLang() {
+    if (_userLang === null) {
+      throw new Error("[models_v2] Default language not set! Call setDefaultLanguage() before using models.");
+    }
+    return _userLang;
+  },
+  get commonLang() {
+    return _commonLang;
+  },
+  get defaultProvenance() {
+    return _defaultProvenance;
+  }
+};
+function setDefaultLanguage(lang) {
+  _userLang = lang;
+}
+var TITLE_PROP = 0;
+var DESCRIPTION_PROP = 1;
+var ORIGINAL_LANG_PROP = 2;
+var AGE_GRADE_BAND_PROP = 3;
+var PREVIEW_TX_ID_PROP = 4;
+var SAFE_PROP = 5;
+var DELETED_PROP = 6;
+var LIFECYCLE_STATUS_PROP = 7;
+function serializeMapOfSets(map) {
+  return Array.from(map.entries()).map(([key, value]) => [key, Array.from(value.values())]);
+}
+function serializeMapOfMaps(mapOfMaps) {
+  return Array.from(mapOfMaps, ([key, innerMap]) => [key, Array.from(innerMap.entries())]);
+}
+var inflateOrmJson = (v2) => {
+  const [id, hasArr, inArr, numArr, boolArr, strArr, instArr] = v2;
+  return [
+    id,
+    new Map(hasArr.map(([rid, set]) => [rid, new Set(set)])),
+    new Map(inArr.map(([rid, set]) => [rid, new Set(set)])),
+    new Map(numArr.map(([pid, langs]) => [pid, new Map(langs)])),
+    new Map(boolArr.map(([pid, langs]) => [pid, new Map(langs)])),
+    new Map(strArr.map(([pid, langs]) => [pid, new Map(langs)])),
+    new Map(instArr)
+  ];
+};
+var warnedLangs = /* @__PURE__ */ new Set();
+var resolveLangValue = (values, lang) => {
+  if (!values) return void 0;
+  if (values.has(lang)) return values.get(lang);
+  if (values.has(LANG_AGNOSTIC)) return values.get(LANG_AGNOSTIC);
+  if (values.size === 1) return values.values().next().value;
+  return void 0;
+};
+var Orm = class extends Stats {
+  constructor(objectType, json, creatorUsername) {
+    const hydrated = json[1] instanceof Map ? json : inflateOrmJson(json);
+    super(hydrated[0], objectType);
+    this._boolValues = /* @__PURE__ */ new Map();
+    this._stringValues = /* @__PURE__ */ new Map();
+    this._numberValues = /* @__PURE__ */ new Map();
+    this._has = /* @__PURE__ */ new Map();
+    this._in = /* @__PURE__ */ new Map();
+    /** lang -> instance array (BookInstanceData structs, not ORM objects). */
+    this._instances = /* @__PURE__ */ new Map();
+    /** lang -> propId -> provenance code (2-bit: unset/AI/human/consensus). */
+    this._provenance = /* @__PURE__ */ new Map();
+    this._id = hydrated[0];
+    this._creatorUsername = creatorUsername;
+    this._has = hydrated[1];
+    this._in = hydrated[2];
+    this._numberValues = hydrated[3];
+    this._boolValues = hydrated[4];
+    this._stringValues = hydrated[5];
+    this._instances = hydrated[6] ?? /* @__PURE__ */ new Map();
+    this.schema = Registry.get(objectType);
+    for (const { relationId, direction } of this.schema.relations ?? []) {
+      const target = direction === "has" ? this._has : this._in;
+      if (!target.has(relationId)) {
+        target.set(relationId, /* @__PURE__ */ new Set());
+      }
+    }
+    for (const pid of [TITLE_PROP, DESCRIPTION_PROP, ORIGINAL_LANG_PROP, PREVIEW_TX_ID_PROP]) {
+      if (!this._stringValues.has(pid)) {
+        this._stringValues.set(pid, /* @__PURE__ */ new Map());
+      }
+    }
+    if (!this._boolValues.has(SAFE_PROP)) {
+      this._boolValues.set(SAFE_PROP, /* @__PURE__ */ new Map([[LANG_AGNOSTIC, true]]));
+    }
+    if (!this._boolValues.has(DELETED_PROP)) {
+      this._boolValues.set(DELETED_PROP, /* @__PURE__ */ new Map([[LANG_AGNOSTIC, false]]));
+    }
+  }
+  static createNewRequest(id) {
+    return [
+      id,
+      /* @__PURE__ */ new Map(),
+      /* @__PURE__ */ new Map(),
+      /* @__PURE__ */ new Map(),
+      /* @__PURE__ */ new Map(),
+      /* @__PURE__ */ new Map(),
+      /* @__PURE__ */ new Map()
+    ];
+  }
+  static async createNewRecord(uidFactory, creatorUsername) {
+    const { wireId, localId } = await uidFactory.next();
+    const op = {
+      operation: PatchOperation.CreateRecord,
+      objectType: this.type,
+      objectId: wireId,
+      langId: 0
+    };
+    PatchInstance.addPatch(op);
+    const emptyJson = [
+      wireId,
+      /* @__PURE__ */ new Map(),
+      /* @__PURE__ */ new Map(),
+      /* @__PURE__ */ new Map(),
+      /* @__PURE__ */ new Map(),
+      /* @__PURE__ */ new Map(),
+      /* @__PURE__ */ new Map()
+    ];
+    const record = new this(emptyJson, creatorUsername);
+    addRecord(this.type, record, creatorUsername);
+    pinRecord(this.type, wireId, creatorUsername);
+    await localRecordTable.putIfAbsent({
+      wireId,
+      creatorUsername,
+      objectType: this.type,
+      localId,
+      createdAt: Date.now(),
+      status: "active"
+    });
+    return record;
+  }
+  get creatorUsername() {
+    if (!isUserCreated(this.id)) return "canonical";
+    return this._creatorUsername ?? "";
+  }
+  toJSON() {
+    return [
+      this._id,
+      serializeMapOfSets(this._has),
+      serializeMapOfSets(this._in),
+      serializeMapOfMaps(this._numberValues),
+      serializeMapOfMaps(this._boolValues),
+      serializeMapOfMaps(this._stringValues),
+      Array.from(this._instances.entries())
+    ];
+  }
+  get id() {
+    return this._id;
+  }
+  // ─── Language helpers ────────────────────────────────────────────────────
+  langOf(langId) {
+    return LANG_ID_DECODE[langId] ?? LANG_AGNOSTIC;
+  }
+  langIdOf(lang) {
+    const l = lang ?? Config.userLang;
+    const id = LANG_ID_ENCODE[l];
+    if (id === void 0) {
+      if (l !== LANG_AGNOSTIC && !warnedLangs.has(l)) {
+        warnedLangs.add(l);
+        console.warn(
+          `[models_v2] Unknown language "${l}" \u2014 patches will land in the lang-agnostic slot (langId 0) and may collide with other unmapped languages. Append "${l}" to LANG_ID_ENCODE in db_schema_v2.`
+        );
+      }
+      return 0;
+    }
+    return id;
+  }
+  // ─── Base props ──────────────────────────────────────────────────────────
+  get title() {
+    return this.getProp(TITLE_PROP) ?? "";
+  }
+  set title(value) {
+    this.dispatchString(TITLE_PROP, value);
+  }
+  getTitle(lang) {
+    return this.getProp(TITLE_PROP, lang) ?? "";
+  }
+  setTitle(value, lang) {
+    this.dispatchString(TITLE_PROP, value, lang);
+  }
+  get description() {
+    return this.getProp(DESCRIPTION_PROP) ?? "";
+  }
+  set description(value) {
+    this.dispatchString(DESCRIPTION_PROP, value);
+  }
+  getDescription(lang) {
+    return this.getProp(DESCRIPTION_PROP, lang) ?? "";
+  }
+  setDescription(value, lang) {
+    this.dispatchString(DESCRIPTION_PROP, value, lang);
+  }
+  get originalLang() {
+    return this.getProp(ORIGINAL_LANG_PROP) ?? "";
+  }
+  set originalLang(value) {
+    this.dispatchString(ORIGINAL_LANG_PROP, value);
+  }
+  getOriginalLang(lang) {
+    return this.getProp(ORIGINAL_LANG_PROP, lang) ?? "";
+  }
+  setOriginalLang(value, lang) {
+    this.dispatchString(ORIGINAL_LANG_PROP, value, lang);
+  }
+  get ageGradeBand() {
+    return this.getProp(AGE_GRADE_BAND_PROP) ?? 0;
+  }
+  set ageGradeBand(value) {
+    this.dispatchNumber(AGE_GRADE_BAND_PROP, value);
+  }
+  get previewTxId() {
+    return this.getProp(PREVIEW_TX_ID_PROP) ?? "";
+  }
+  set previewTxId(value) {
+    this.dispatchString(PREVIEW_TX_ID_PROP, value);
+  }
+  get safe() {
+    return this.getProp(SAFE_PROP) ?? true;
+  }
+  set safe(value) {
+    this.dispatchNumber(SAFE_PROP, value ? 1 : 0);
+  }
+  get deleted() {
+    return this.getProp(DELETED_PROP) ?? false;
+  }
+  set deleted(value) {
+    this.dispatchNumber(DELETED_PROP, value ? 1 : 0);
+  }
+  get lifecycleStatus() {
+    return this.getProp(LIFECYCLE_STATUS_PROP) ?? 0 /* Provisional */;
+  }
+  set lifecycleStatus(value) {
+    if (!isUserCreated(this.id)) {
+      throw new Error("lifecycleStatus can only be set on user-created provisional records");
+    }
+    if (!this._creatorUsername) throw new Error("Missing creatorUsername on provisional record");
+    if (value < this.lifecycleStatus) {
+      throw new Error(`lifecycleStatus is forward-only: cannot transition from ${this.lifecycleStatus} to ${value}`);
+    }
+    this.dispatchNumber(LIFECYCLE_STATUS_PROP, value, LANG_AGNOSTIC);
+  }
+  // ─── Patch dispatch (mutation entry points used by generated setters) ────
+  dispatchString(propertyId, value, lang) {
+    const op = {
+      operation: PatchOperation.EditPropertyString,
+      objectType: this.objectType,
+      objectId: this.id,
+      langId: this.langIdOf(lang),
+      propertyId,
+      value
+    };
+    this.patch(op);
+    const targetLang = lang ?? Config.userLang;
+    const prov = Config.defaultProvenance;
+    if (prov !== void 0 && this.getProvenance(propertyId, targetLang) !== prov) {
+      this.setProvenanceRaw(targetLang, propertyId, prov);
+    }
+    PatchInstance.addPatch(op);
+  }
+  dispatchNumber(propertyId, value, lang) {
+    const op = {
+      operation: PatchOperation.EditPropertyNumber,
+      objectType: this.objectType,
+      objectId: this.id,
+      langId: this.langIdOf(lang),
+      propertyId,
+      value
+    };
+    this.patch(op);
+    const targetLang = lang ?? Config.userLang;
+    const prov = Config.defaultProvenance;
+    if (prov !== void 0 && this.getProvenance(propertyId, targetLang) !== prov) {
+      this.setProvenanceRaw(targetLang, propertyId, prov);
+    }
+    PatchInstance.addPatch(op);
+  }
+  dispatchRelation(relationId, action, targetId) {
+    const op = {
+      operation: PatchOperation.EditRelation,
+      objectType: this.objectType,
+      objectId: this.id,
+      langId: 0,
+      relationId,
+      action,
+      targetId
+    };
+    this.patch(op);
+    PatchInstance.addPatch(op);
+  }
+  /**
+   * Raw in-memory relation mutation: no patch is emitted. Used by the
+   * generic inverse propagation in patch() and by generated in-side
+   * relation helpers. Idempotent (Set semantics).
+   */
+  applyRelationRaw(direction, relationId, action, targetId) {
+    const map = direction === "has" ? this._has : this._in;
+    if (!map.has(relationId)) map.set(relationId, /* @__PURE__ */ new Set());
+    if (action === PatchAction.Add) {
+      map.get(relationId).add(targetId);
+    } else {
+      map.get(relationId).delete(targetId);
+    }
+    dbReactivity.trigger(this);
+  }
+  /**
+   * Bulk-restores the inverse (`in`) edges implied by this record's forward
+   * (`has`) relations onto their target records. The sidecar serializes only
+   * the `has` direction (§3.7.1); `mergeExtended` fills `_has`, but the inverse
+   * side (`Person.authorOf`, `Tag.inTags`, …) stays empty until this runs.
+   *
+   * No patch emitted, no reactivity fired (bulk boot path). Idempotent (Set
+   * add). Targets must already be materialized — call after a full
+   * `hydrateAll` pass (see `rebuildInverseRelations`).
+   */
+  restoreInverses() {
+    for (const [relationId, targets] of this._has) {
+      const rel = this.schema.relations?.find((r) => r.relationId === relationId);
+      if (!rel?.inverted) continue;
+      const targetSchema = Registry.getByName(rel.targetType);
+      const invRel = targetSchema?.relations.find((r) => r.name === rel.inverted);
+      if (!targetSchema || !invRel) continue;
+      for (const targetId of targets) {
+        if (!hasRecord(targetSchema.objectId, targetId, this.creatorUsername)) continue;
+        const target = getRecord(targetSchema.objectId, targetId, this.creatorUsername);
+        let set = target._in.get(invRel.relationId);
+        if (!set) {
+          set = /* @__PURE__ */ new Set();
+          target._in.set(invRel.relationId, set);
+        }
+        set.add(this._id);
+      }
+    }
+  }
+  /**
+   * Applies a V2 patch to the in-memory state. Triggers reactivity.
+   */
+  patch(patch, _isMine = true) {
+    track(patch);
+    switch (patch.operation) {
+      case PatchOperation.EditPropertyString: {
+        const p = patch;
+        if (!this._stringValues.has(p.propertyId)) {
+          this._stringValues.set(p.propertyId, /* @__PURE__ */ new Map());
+        }
+        this._stringValues.get(p.propertyId).set(this.langOf(p.langId), p.value);
+        break;
+      }
+      case PatchOperation.EditPropertyNumber: {
+        const p = patch;
+        if (p.propertyId === LIFECYCLE_STATUS_PROP) {
+          const statusStr = p.value === 1 /* Submitted */ ? "submitted" : p.value === 2 /* CommunityPending */ ? "community_pending" : p.value === 3 /* Canonical */ ? "canonical" : "active";
+          localRecordTable.setStatus(this.creatorUsername, this.id, statusStr).catch((err) => {
+            if (!err.message?.includes("not found")) {
+              console.error("[Orm] Failed to update LocalRecordTable status:", err);
+            }
+          });
+          if (p.value === 3 /* Canonical */) {
+            unpinRecord(this.objectType, this.id, this.creatorUsername);
+          }
+        }
+        const lang = this.langOf(p.langId);
+        if (this.getPropType(p.propertyId) === "boolean") {
+          if (!this._boolValues.has(p.propertyId)) {
+            this._boolValues.set(p.propertyId, /* @__PURE__ */ new Map());
+          }
+          this._boolValues.get(p.propertyId).set(lang, !!p.value);
+        } else {
+          if (!this._numberValues.has(p.propertyId)) {
+            this._numberValues.set(p.propertyId, /* @__PURE__ */ new Map());
+          }
+          this._numberValues.get(p.propertyId).set(lang, p.value);
+        }
+        break;
+      }
+      case PatchOperation.EditInstanceFieldString:
+      case PatchOperation.EditInstanceFieldNumber: {
+        const p = patch;
+        this.applyInstancePatch(p);
+        break;
+      }
+      case PatchOperation.EditRelation: {
+        const p = patch;
+        const rel = this.schema.relations?.find((r) => r.relationId === p.relationId);
+        const direction = rel?.direction ?? (this._in.has(p.relationId) && !this._has.has(p.relationId) ? "in" : "has");
+        this.applyRelationRaw(direction, p.relationId, p.action, p.targetId);
+        if (rel?.inverted) {
+          const targetSchema = Registry.getByName(rel.targetType);
+          const invRel = targetSchema?.relations.find((r) => r.name === rel.inverted);
+          if (targetSchema && invRel && hasRecord(targetSchema.objectId, p.targetId, this.creatorUsername)) {
+            const target = getRecord(targetSchema.objectId, p.targetId, this.creatorUsername);
+            target.applyRelationRaw(invRel.direction, invRel.relationId, p.action, this._id);
+          }
+        }
+        break;
+      }
+      case PatchOperation.SetAlias:
+        break;
+      case PatchOperation.AddInstance: {
+        const p = patch;
+        const lang = this.langOf(p.langId);
+        let arr = this._instances.get(lang);
+        if (!arr) {
+          arr = [];
+          this._instances.set(lang, arr);
+        }
+        while (arr.length <= p.instanceIndex) arr.push({});
+        break;
+      }
+      case PatchOperation.CreateRecord:
+        break;
+      default:
+        throw new Error(`unhandled patch operation ${patch.operation}`);
+    }
+    dbReactivity.trigger(this);
+  }
+  applyInstancePatch(p) {
+    const lang = this.langOf(p.langId);
+    let arr = this._instances.get(lang);
+    if (!arr) {
+      arr = [];
+      this._instances.set(lang, arr);
+    }
+    while (arr.length <= p.instanceIndex) arr.push({});
+    const field = this.schema.instanceFields?.find((f) => f.propId === p.propertyId);
+    const name = field?.name ?? `field${p.propertyId}`;
+    let value = p.value;
+    if (field?.type === "boolean" && typeof value === "number") {
+      value = !!value;
+    }
+    arr[p.instanceIndex][name] = value;
+  }
+  // ─── Typed property access ───────────────────────────────────────────────
+  getPropType(propId) {
+    switch (propId) {
+      case TITLE_PROP:
+      case DESCRIPTION_PROP:
+      case ORIGINAL_LANG_PROP:
+      case PREVIEW_TX_ID_PROP:
+        return "string";
+      case AGE_GRADE_BAND_PROP:
+      case LIFECYCLE_STATUS_PROP:
+        return "number";
+      case SAFE_PROP:
+      case DELETED_PROP:
+        return "boolean";
+    }
+    const propDefinition = this.schema.props.find((prop) => prop.propId === propId);
+    if (typeof propDefinition === "undefined") {
+      throw new Error(`unknown prop ${propId} in schema ${this.schema.name}`);
+    }
+    return propDefinition.type === "enum" ? "number" : propDefinition.type;
+  }
+  getProp(propId, lang) {
+    dbReactivity.track(this);
+    const l = lang ?? Config.userLang;
+    switch (this.getPropType(propId)) {
+      case "string":
+        return resolveLangValue(this._stringValues.get(propId), l) ?? "";
+      case "number":
+        return resolveLangValue(this._numberValues.get(propId), l);
+      case "boolean":
+        return resolveLangValue(this._boolValues.get(propId), l);
+    }
+  }
+  /** Direct state write — no patch emitted (used by merge methods). */
+  setRaw(propId, value, lang = LANG_AGNOSTIC) {
+    switch (this.getPropType(propId)) {
+      case "string": {
+        if (!this._stringValues.has(propId)) this._stringValues.set(propId, /* @__PURE__ */ new Map());
+        this._stringValues.get(propId).set(lang, value);
+        break;
+      }
+      case "number": {
+        if (!this._numberValues.has(propId)) this._numberValues.set(propId, /* @__PURE__ */ new Map());
+        this._numberValues.get(propId).set(lang, value);
+        break;
+      }
+      case "boolean": {
+        if (!this._boolValues.has(propId)) this._boolValues.set(propId, /* @__PURE__ */ new Map());
+        this._boolValues.get(propId).set(lang, !!value);
+        break;
+      }
+    }
+  }
+  // ─── Instances ───────────────────────────────────────────────────────────
+  getInstancesData(lang) {
+    dbReactivity.track(this);
+    return this._instances.get(lang ?? Config.userLang) ?? [];
+  }
+  getDefaultInstanceData(lang) {
+    const all = this.getInstancesData(lang);
+    return all.find((i) => i["isDefault"] === true) ?? all[0];
+  }
+  /** Direct state write — no patch emitted (used by mergeExtended/mergeSlim). */
+  setInstancesRaw(lang, instances) {
+    this._instances.set(lang, instances);
+  }
+  growInstances(lang, toIndex) {
+    let arr = this._instances.get(lang);
+    if (!arr) {
+      arr = [];
+      this._instances.set(lang, arr);
+    }
+    while (arr.length <= toIndex) {
+      arr.push({});
+    }
+  }
+  addInstance(lang) {
+    if (!this.schema.multipleInstances) {
+      throw new Error(`Model ${this.constructor.name} does not support multiple instances.`);
+    }
+    const targetLang = lang ?? Config.userLang;
+    const instances = this.getInstancesData(targetLang);
+    const index = instances.length;
+    this.growInstances(targetLang, index);
+    const op = {
+      operation: PatchOperation.AddInstance,
+      objectType: this.objectType,
+      objectId: this.id,
+      langId: this.langIdOf(targetLang),
+      instanceIndex: index
+    };
+    this.patch(op);
+    PatchInstance.addPatch(op);
+    return index;
+  }
+  // ─── Provenance ──────────────────────────────────────────────────────────
+  getProvenance(propId, lang) {
+    dbReactivity.track(this);
+    return this._provenance.get(lang ?? Config.userLang)?.get(propId) ?? 0;
+  }
+  setProvenanceRaw(lang, propId, value) {
+    if (!this._provenance.has(lang)) this._provenance.set(lang, /* @__PURE__ */ new Map());
+    this._provenance.get(lang).set(propId, value);
+  }
+  // ─── Generic Merge ───────────────────────────────────────────────────────
+  mergeSlim(cols, index, lang = Config.userLang) {
+    this.setRaw(0, cols.titles?.[index] ?? "", lang);
+    this.setRaw(2, cols.originalLangs?.[index] ?? "", lang);
+    this.setRaw(4, cols.previewTxIds?.[index] ?? "", lang);
+    this.setRaw(3, cols.ageGradeBands?.[index], lang);
+    this.setRaw(5, cols.safes?.[index] === 1, lang);
+    this.setRaw(6, cols.deleteds?.[index] === 1, lang);
+    for (const prop of this.schema.props) {
+      if (prop.source !== "slim") continue;
+      const name = colName(prop.name, prop.type);
+      const val = cols[name]?.[index];
+      if (prop.type === "string") {
+        this.setRaw(prop.propId, val ?? "", lang);
+      } else if (prop.type === "boolean") {
+        this.setRaw(prop.propId, val === 1, lang);
+      } else {
+        this.setRaw(prop.propId, val, lang);
+      }
+    }
+    if (this.schema.multipleInstances) {
+      const firstStrField = this.schema.instanceFields?.find((f) => f.type === "string");
+      let hasDefault = true;
+      if (firstStrField) {
+        const name = `default${colName(capitalize(firstStrField.name), firstStrField.type)}`;
+        if (cols[name]?.[index] == null) {
+          hasDefault = false;
+        }
+      }
+      if (hasDefault && this.getInstancesData(lang).length === 0) {
+        const inst = { isDefault: true };
+        for (const field of this.schema.instanceFields || []) {
+          const name = `default${colName(capitalize(field.name), field.type)}`;
+          const val = cols[name]?.[index];
+          if (field.type === "boolean") {
+            inst[field.name] = val === 1;
+          } else {
+            inst[field.name] = val ?? null;
+          }
+        }
+        this.setInstancesRaw(lang, [inst]);
+      }
+    }
+  }
+  mergeExtended(cols, index, lang = Config.userLang) {
+    this.setRaw(1, cols.descriptions?.[index] ?? "", lang);
+    for (const prop of this.schema.props) {
+      if (prop.source !== "extended") continue;
+      const name = colName(prop.name, prop.type);
+      const val = cols[name]?.[index];
+      if (prop.type === "string") {
+        this.setRaw(prop.propId, val ?? "", lang);
+      } else if (prop.type === "boolean") {
+        this.setRaw(prop.propId, val === 1, lang);
+      } else {
+        this.setRaw(prop.propId, val, lang);
+      }
+    }
+    for (const rel of this.schema.relations || []) {
+      if (rel.direction !== "has") continue;
+      const field = relationColName2(rel);
+      if (cols[field]) {
+        const set = this._has.get(rel.relationId);
+        for (const targetId of cols[field][index] ?? []) {
+          set.add(targetId);
+        }
+      }
+    }
+    if (this.schema.multipleInstances) {
+      if (cols.instances) {
+        this.setInstancesRaw(lang, cols.instances[index] ?? []);
+      }
+    }
+  }
+  mergeProv(cols, index, lang = Config.userLang) {
+    const BASE_PROP_IDS = {
+      title: 0,
+      description: 1,
+      originalLang: 2,
+      ageGradeBand: 3,
+      previewTxId: 4,
+      safe: 5,
+      deleted: 6,
+      lifecycleStatus: 7
+    };
+    for (const [name, arr] of Object.entries(cols.fields || {})) {
+      let propId = BASE_PROP_IDS[name];
+      if (propId === void 0) {
+        const prop = this.schema.props.find((p) => p.name === name);
+        if (prop) {
+          propId = prop.propId;
+        } else if (this.schema.instanceFields) {
+          const field = this.schema.instanceFields.find((f) => f.name === name);
+          if (field) propId = field.propId;
+        }
+      }
+      if (propId !== void 0) {
+        this.setProvenanceRaw(lang, propId, arr[index]);
+      }
+    }
+  }
+};
+
+// src/models/pid.ts
+var BASE34_ALPHABET = "0123456789ABCDEFGHJKLMNPQRSTUVWXYZ";
+var ISO_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ*";
+function computeMod37_2(input) {
+  let p = 0;
+  for (let i = 0; i < input.length; i++) {
+    const val = ISO_ALPHABET.indexOf(input[i]);
+    if (val === -1) {
+      throw new Error(`[pid] Invalid character for ISO 7064 MOD 37-2: ${input[i]}`);
+    }
+    let s = (p + val) % 37;
+    if (s === 0) s = 37;
+    p = s * 2 % 37;
+  }
+  const checkVal = (38 - p) % 37;
+  let checkChar = ISO_ALPHABET[checkVal];
+  if (checkChar === "*") checkChar = "X";
+  if (checkChar === "I") checkChar = "J";
+  if (checkChar === "O") checkChar = "P";
+  return checkChar;
+}
+function base34(wireId) {
+  if (!Number.isInteger(wireId) || wireId < 0 || wireId > 4294967295) {
+    throw new Error(`[pid] wireId ${wireId} must be an unsigned 32-bit integer`);
+  }
+  if (wireId === 0) return "0000000";
+  let str = "";
+  let val = wireId;
+  while (val > 0) {
+    str = BASE34_ALPHABET[val % 34] + str;
+    val = Math.floor(val / 34);
+  }
+  return str.padStart(7, "0");
+}
+function unbase34(str) {
+  if (str.length !== 7) {
+    throw new Error(`[pid] Base34 body must be exactly 7 characters, got ${str.length}`);
+  }
+  let val = 0;
+  for (let i = 0; i < str.length; i++) {
+    const idx = BASE34_ALPHABET.indexOf(str[i]);
+    if (idx === -1) {
+      throw new Error(`[pid] Invalid character in base-34 body: ${str[i]}`);
+    }
+    val = val * 34 + idx;
+  }
+  return val;
+}
+function encodePID(typePrefix, wireId) {
+  if (typePrefix.length !== 2) {
+    throw new Error(`[pid] typePrefix must be exactly 2 characters`);
+  }
+  const body = base34(wireId);
+  const check2 = computeMod37_2(typePrefix + body);
+  return typePrefix + body + check2;
+}
+function decodePID(typePrefix, pid) {
+  if (!pid.startsWith(typePrefix)) {
+    throw new Error(`[pid] PID ${pid} does not start with expected prefix ${typePrefix}`);
+  }
+  if (pid.length !== 10) {
+    throw new Error(`[pid] PID must be exactly 10 characters long, got ${pid.length}`);
+  }
+  const body = pid.slice(2, 9);
+  const providedCheck = pid[9];
+  const expectedCheck = computeMod37_2(typePrefix + body);
+  if (providedCheck !== expectedCheck) {
+    throw new Error(`[pid] Invalid check character in PID ${pid}. Expected ${expectedCheck}`);
+  }
+  return { wireId: unbase34(body) };
+}
+
+// ../db_schemas/dist/schemas.js
+var schemas = {
+  "Book": {
+    "name": "Book",
+    "typePrefix": "BK",
+    "canonical": true,
+    "uidStrategy": "native-only",
+    "multipleInstances": true,
+    "instanceUidStrategy": [
+      "isbn"
+    ],
+    "props": [
+      {
+        "name": "prerequisites",
+        "type": "string",
+        "source": "extended",
+        "propId": 8
+      },
+      {
+        "name": "deweyDecimal",
+        "type": "string",
+        "source": "extended",
+        "propId": 9
+      },
+      {
+        "name": "locCallNumber",
+        "type": "string",
+        "source": "extended",
+        "propId": 10
+      },
+      {
+        "name": "copyrightStatus",
+        "type": "enum",
+        "enum": "CopyrightStatus",
+        "source": "extended",
+        "propId": 11
+      },
+      {
+        "name": "textQuality",
+        "type": "enum",
+        "enum": "QualityScore",
+        "source": "extended",
+        "propId": 12
+      },
+      {
+        "name": "illustrations",
+        "type": "enum",
+        "enum": "QualityScore",
+        "source": "extended",
+        "propId": 13
+      },
+      {
+        "name": "educationQuality",
+        "type": "enum",
+        "enum": "QualityScore",
+        "source": "extended",
+        "propId": 14
+      },
+      {
+        "name": "practicality",
+        "type": "enum",
+        "enum": "QualityScore",
+        "source": "extended",
+        "propId": 15
+      },
+      {
+        "name": "accessibilityLevel",
+        "type": "enum",
+        "enum": "QualityScore",
+        "source": "extended",
+        "propId": 16
+      },
+      {
+        "name": "teacherMaterials",
+        "type": "boolean",
+        "source": "extended",
+        "propId": 17
+      },
+      {
+        "name": "pedagogicalScaffolding",
+        "type": "enum",
+        "enum": "QualityScore",
+        "source": "extended",
+        "propId": 18
+      },
+      {
+        "name": "clarityOfExplanation",
+        "type": "enum",
+        "enum": "QualityScore",
+        "source": "extended",
+        "propId": 19
+      },
+      {
+        "name": "workedExamples",
+        "type": "enum",
+        "enum": "QualityScore",
+        "source": "extended",
+        "propId": 20
+      },
+      {
+        "name": "exercisesAndAssessment",
+        "type": "enum",
+        "enum": "QualityScore",
+        "source": "extended",
+        "propId": 21
+      },
+      {
+        "name": "selfStudyReadiness",
+        "type": "enum",
+        "enum": "QualityScore",
+        "source": "extended",
+        "propId": 22
+      },
+      {
+        "name": "referenceApparatus",
+        "type": "enum",
+        "enum": "QualityScore",
+        "source": "extended",
+        "propId": 23
+      },
+      {
+        "name": "safetyGuidance",
+        "type": "enum",
+        "enum": "QualityScore",
+        "source": "extended",
+        "propId": 24
+      },
+      {
+        "name": "contentCurrency",
+        "type": "enum",
+        "enum": "QualityScore",
+        "source": "extended",
+        "propId": 25
+      },
+      {
+        "name": "ecoRegeneration",
+        "type": "enum",
+        "enum": "QualityScore",
+        "source": "extended",
+        "propId": 26
+      },
+      {
+        "name": "communityLiving",
+        "type": "enum",
+        "enum": "QualityScore",
+        "source": "extended",
+        "propId": 27
+      },
+      {
+        "name": "promotesPeace",
+        "type": "enum",
+        "enum": "QualityScore",
+        "source": "extended",
+        "propId": 28
+      },
+      {
+        "name": "businessDevelopment",
+        "type": "enum",
+        "enum": "QualityScore",
+        "source": "extended",
+        "propId": 29
+      }
+    ],
+    "instanceFields": [
+      {
+        "name": "language",
+        "type": "string",
+        "identityComponent": true,
+        "propId": 30
+      },
+      {
+        "name": "downloadTxId",
+        "type": "string",
+        "propId": 31
+      },
+      {
+        "name": "method",
+        "type": "enum",
+        "enum": "BookMethod",
+        "propId": 32
+      },
+      {
+        "name": "isAiTranslation",
+        "type": "boolean",
+        "propId": 33
+      },
+      {
+        "name": "aiEngine",
+        "type": "string",
+        "nullable": true,
+        "propId": 34
+      },
+      {
+        "name": "addedAt",
+        "type": "number",
+        "bits": 32,
+        "propId": 35
+      },
+      {
+        "name": "nbPages",
+        "type": "number",
+        "bits": 16,
+        "propId": 36
+      },
+      {
+        "name": "sizeBytes",
+        "type": "number",
+        "bits": 32,
+        "propId": 37
+      },
+      {
+        "name": "publisher",
+        "type": "string",
+        "nullable": true,
+        "propId": 38
+      },
+      {
+        "name": "publicationDate",
+        "type": "string",
+        "nullable": true,
+        "propId": 39
+      },
+      {
+        "name": "publishedAt",
+        "type": "string",
+        "nullable": true,
+        "propId": 40
+      },
+      {
+        "name": "qualityScore",
+        "type": "enum",
+        "enum": "QualityScore",
+        "propId": 41
+      },
+      {
+        "name": "isbn",
+        "type": "string",
+        "nullable": true,
+        "source": "extended",
+        "propId": 42
+      }
+    ],
+    "relations": [
+      {
+        "name": "inTags",
+        "targetType": "Tag",
+        "direction": "in",
+        "inverted": "books",
+        "relationId": 0
+      },
+      {
+        "name": "authors",
+        "targetType": "Person",
+        "direction": "has",
+        "inverted": "authorOf",
+        "relationId": 1
+      }
+    ],
+    "translations": {
+      "fr": {
+        "className": "Livre",
+        "props": {
+          "title": "titre",
+          "description": "description"
+        }
+      }
+    },
+    "standardPks": {
+      "isbn": "isbn"
+    },
+    "objectId": 0
+  },
+  "Person": {
+    "name": "Person",
+    "typePrefix": "PR",
+    "canonical": true,
+    "uidStrategy": [
+      "isni",
+      "orcid"
+    ],
+    "multipleInstances": false,
+    "props": [
+      {
+        "name": "birthDate",
+        "type": "string",
+        "source": "extended",
+        "propId": 43
+      },
+      {
+        "name": "deathDate",
+        "type": "string",
+        "source": "extended",
+        "propId": 44
+      },
+      {
+        "name": "nationality",
+        "type": "string",
+        "source": "extended",
+        "propId": 45
+      },
+      {
+        "name": "wikiUrl",
+        "type": "string",
+        "source": "extended",
+        "propId": 46
+      },
+      {
+        "name": "isniId",
+        "type": "string",
+        "nullable": true,
+        "source": "extended",
+        "propId": 47
+      },
+      {
+        "name": "orcidId",
+        "type": "string",
+        "nullable": true,
+        "source": "extended",
+        "propId": 48
+      }
+    ],
+    "instanceFields": [],
+    "relations": [
+      {
+        "name": "authorOf",
+        "targetType": "Book",
+        "direction": "in",
+        "inverted": "authors",
+        "relationId": 2
+      }
+    ],
+    "translations": {
+      "fr": {
+        "className": "Personne"
+      }
+    },
+    "standardPks": {
+      "isni": "isniId",
+      "orcid": "orcidId"
+    },
+    "objectId": 1
+  },
+  "Tag": {
+    "name": "Tag",
+    "typePrefix": "TG",
+    "canonical": true,
+    "uidStrategy": [
+      "lcc",
+      "ddc",
+      "udc",
+      "clc",
+      "bbk",
+      "tlc",
+      "cc"
+    ],
+    "multipleInstances": false,
+    "props": [
+      {
+        "name": "lccNotation",
+        "type": "string",
+        "nullable": true,
+        "source": "extended",
+        "propId": 50
+      },
+      {
+        "name": "ddcNotation",
+        "type": "string",
+        "nullable": true,
+        "source": "extended",
+        "propId": 49
+      },
+      {
+        "name": "udcNotation",
+        "type": "string",
+        "nullable": true,
+        "source": "extended",
+        "propId": 51
+      },
+      {
+        "name": "clcNotation",
+        "type": "string",
+        "nullable": true,
+        "source": "extended",
+        "propId": 52
+      },
+      {
+        "name": "bbkNotation",
+        "type": "string",
+        "nullable": true,
+        "source": "extended",
+        "propId": 53
+      },
+      {
+        "name": "tlcNotation",
+        "type": "string",
+        "nullable": true,
+        "source": "extended",
+        "propId": 54
+      },
+      {
+        "name": "ccNotation",
+        "type": "string",
+        "nullable": true,
+        "source": "extended",
+        "propId": 55
+      }
+    ],
+    "instanceFields": [],
+    "relations": [
+      {
+        "name": "inTags",
+        "targetType": "Tag",
+        "direction": "in",
+        "inverted": "tags",
+        "relationId": 0
+      },
+      {
+        "name": "tags",
+        "targetType": "Tag",
+        "direction": "has",
+        "inverted": "inTags",
+        "relationId": 3
+      },
+      {
+        "name": "books",
+        "targetType": "Book",
+        "direction": "has",
+        "inverted": "inTags",
+        "relationId": 4
+      }
+    ],
+    "standardPks": {
+      "lcc": "lccNotation",
+      "ddc": "ddcNotation",
+      "udc": "udcNotation",
+      "clc": "clcNotation",
+      "bbk": "bbkNotation",
+      "tlc": "tlcNotation",
+      "cc": "ccNotation"
+    },
+    "objectId": 2
+  }
+};
+
+// ../standard-adapters/dist/chunk-DX6SH342.js
+function validateISNIMod11_2(compact) {
+  if (compact.length !== 16) return { valid: false, error: `Expected 16 chars, got ${compact.length}` };
+  let p = 0;
+  for (let i = 0; i < 15; i++) {
+    const d = parseInt(compact[i], 10);
+    if (isNaN(d)) return { valid: false, error: `Non-digit character at position ${i}` };
+    p = (p + d) * 2 % 11;
+  }
+  const checkVal = (12 - p) % 11;
+  const checkChar = checkVal === 10 ? "X" : String(checkVal);
+  if (compact[15].toUpperCase() !== checkChar)
+    return { valid: false, error: `Check digit mismatch: expected ${checkChar}, got ${compact[15]}` };
+  return { valid: true };
+}
+var ISNIAdapter = {
+  standardId: "isni",
+  uriScheme: "ISNI",
+  normalize(value) {
+    return value.replace(/[\s-]/g, "");
+  },
+  display(value) {
+    const compact = ISNIAdapter.normalize(value);
+    if (compact.length === 16)
+      return `${compact.slice(0, 4)} ${compact.slice(4, 8)} ${compact.slice(8, 12)} ${compact.slice(12)}`;
+    return compact;
+  },
+  validate(value) {
+    if (!value) return { valid: false, error: "ISNI is absent" };
+    const compact = ISNIAdapter.normalize(value);
+    if (!/^[0-9]{15}[0-9X]$/.test(compact))
+      return { valid: false, error: `ISNI does not match pattern: ${compact}` };
+    return validateISNIMod11_2(compact);
+  },
+  toLinkedDataUri(value) {
+    return `https://isni.org/isni/${ISNIAdapter.normalize(value)}`;
+  },
+  apis: {
+    "isni-sru": {
+      apiId: "isni-sru",
+      name: "ISNI SRU API",
+      async fetch({ isniId }) {
+        if (!isniId) return [];
+        const query = `pica.isn%3D${encodeURIComponent(isniId)}`;
+        const url = `https://isni.oclc.org/sru/DB=1.2/?operation=searchRetrieve&query=${query}&recordSchema=isni-b&maximumRecords=10`;
+        const res = await fetch(url, { headers: { Accept: "application/xml" } });
+        if (!res.ok) return [];
+        const text = await res.text();
+        const isniMatch = text.match(/<isniUnformatted>([0-9X]+)<\/isniUnformatted>/);
+        const forenameMatch = text.match(/<forename>([^<]+)<\/forename>/);
+        const surnameMatch = text.match(/<surname>([^<]+)<\/surname>/);
+        if (!isniMatch) return [];
+        return [{
+          isni: isniMatch[1],
+          forename: forenameMatch?.[1],
+          surname: surnameMatch?.[1]
+        }];
+      }
+    }
+  }
+};
+
+// ../standard-adapters/dist/chunk-KNGZ7NJF.js
+function validateORCIDMod11_2(compact) {
+  if (compact.length !== 16) return { valid: false, error: `Expected 16 chars, got ${compact.length}` };
+  let p = 0;
+  for (let i = 0; i < 15; i++) {
+    const d = parseInt(compact[i], 10);
+    if (isNaN(d)) return { valid: false, error: `Non-digit at position ${i}` };
+    p = (p + d) * 2 % 11;
+  }
+  const checkVal = (12 - p) % 11;
+  const checkChar = checkVal === 10 ? "X" : String(checkVal);
+  if (compact[15].toUpperCase() !== checkChar)
+    return { valid: false, error: `Check digit mismatch: expected ${checkChar}, got ${compact[15]}` };
+  return { valid: true };
+}
+var ORCID_API_BASE = "https://pub.orcid.org/v3.0";
+var ORCID_HEADERS = { Accept: "application/vnd.orcid+json" };
+var ORCIDAdapter = {
+  standardId: "orcid",
+  uriScheme: "ORCID",
+  normalize(value) {
+    const clean = value.replace(/\s/g, "");
+    if (clean.length === 16 && !clean.includes("-"))
+      return `${clean.slice(0, 4)}-${clean.slice(4, 8)}-${clean.slice(8, 12)}-${clean.slice(12)}`;
+    return clean;
+  },
+  display(value) {
+    return ORCIDAdapter.normalize(value);
+  },
+  validate(value) {
+    if (!value) return { valid: false, error: "ORCID iD is absent" };
+    const normalized = ORCIDAdapter.normalize(value);
+    if (!/^[0-9]{4}-[0-9]{4}-[0-9]{4}-[0-9]{3}[0-9X]$/.test(normalized))
+      return { valid: false, error: `ORCID iD does not match pattern: ${normalized}` };
+    return validateORCIDMod11_2(normalized.replace(/-/g, ""));
+  },
+  toLinkedDataUri(value) {
+    return `https://orcid.org/${ORCIDAdapter.normalize(value)}`;
+  },
+  apis: {
+    "orcid-lookup": {
+      apiId: "orcid-lookup",
+      name: "ORCID Public Record API",
+      async fetch({ orcidId }) {
+        if (!orcidId) return {};
+        const res = await fetch(`${ORCID_API_BASE}/${orcidId}/record`, { headers: ORCID_HEADERS });
+        if (!res.ok) return {};
+        const data = await res.json();
+        const person = data.person ?? {};
+        const name = person.name ?? {};
+        return {
+          orcidId,
+          givenNames: name["given-names"]?.value,
+          familyName: name["family-name"]?.value,
+          biography: person.biography?.content ?? void 0
+        };
+      }
+    },
+    "orcid-public-api": {
+      apiId: "orcid-public-api",
+      name: "ORCID Public Search API",
+      async fetch({ orcidId }) {
+        if (!orcidId) return [];
+        const res = await fetch(
+          `${ORCID_API_BASE}/search?q=orcid:${orcidId}&rows=10`,
+          { headers: ORCID_HEADERS }
+        );
+        if (!res.ok) return [];
+        const data = await res.json();
+        return (data.result ?? []).map((r) => {
+          const item = r;
+          const oid = item["orcid-identifier"]?.path;
+          return { orcidId: oid ?? "" };
+        }).filter((r) => r.orcidId);
+      }
+    }
+  }
+};
+
+// src/models/generated-src/Person.ts
+var schema = schemas["Person"];
+Registry.register(schema);
+var PERSON_PROP_IDS = { title: 0, description: 1, originalLang: 2, ageGradeBand: 3, previewTxId: 4, safe: 5, deleted: 6, lifecycleStatus: 7, birthDate: 43, deathDate: 44, nationality: 45, wikiUrl: 46, isniId: 47, orcidId: 48 };
+function serializePersonSlim(records) {
+  return commonSerializeSlim(schema, records, currentLayout());
+}
+function serializePersonExtended(records) {
+  return commonSerializeExtended(schema, records, currentLayout());
+}
+function serializePersonProv(records) {
+  return commonSerializeProv(schema, records);
+}
+var _Person = class _Person extends Orm {
+  constructor(json, creatorUsername) {
+    super(_Person.type, json, creatorUsername);
+  }
+  /** Synchronous LRU read — throws on miss (use LoadAsync to re-hydrate). */
+  static Load(id, creatorUsername) {
+    return getRecord(_Person.type, id, creatorUsername);
+  }
+  static Has(id, creatorUsername) {
+    return hasRecord(_Person.type, id, creatorUsername);
+  }
+  /** On-demand hydration from the worker after LRU eviction (SPEC §2.5). */
+  static async LoadAsync(id, creatorUsername) {
+    if (hasRecord(_Person.type, id, creatorUsername)) {
+      return getRecord(_Person.type, id, creatorUsername);
+    }
+    const thread = PatchInstance.threadInstance;
+    if (!thread) throw new Error("worker thread not initialized \u2014 call PatchInstance.initThread first");
+    const res = await thread.sendRequest({
+      cmd: "getRecord" /* GetRecord */,
+      payload: { objectType: _Person.type, id }
+    });
+    if (!res || res.length === 0) throw new Error(`Person ${id} not found in worker storage`);
+    const record = NewPersonWithId(id, creatorUsername);
+    for (const data of res) {
+      if (data.slim) record.mergeSlim(data.slim, 0, data.lang);
+      if (data.extended) record.mergeExtended(data.extended, 0, data.lang);
+      if (data.prov) record.mergeProv(data.prov, 0, data.lang);
+    }
+    return record;
+  }
+  get birthDate() {
+    return this.getProp(43);
+  }
+  set birthDate(value) {
+    this.dispatchString(43, value);
+  }
+  getBirthDate(lang) {
+    return this.getProp(43, lang);
+  }
+  setBirthDate(value, lang) {
+    this.dispatchString(43, value, lang);
+  }
+  get deathDate() {
+    return this.getProp(44);
+  }
+  set deathDate(value) {
+    this.dispatchString(44, value);
+  }
+  getDeathDate(lang) {
+    return this.getProp(44, lang);
+  }
+  setDeathDate(value, lang) {
+    this.dispatchString(44, value, lang);
+  }
+  get nationality() {
+    return this.getProp(45);
+  }
+  set nationality(value) {
+    this.dispatchString(45, value);
+  }
+  getNationality(lang) {
+    return this.getProp(45, lang);
+  }
+  setNationality(value, lang) {
+    this.dispatchString(45, value, lang);
+  }
+  get wikiUrl() {
+    return this.getProp(46);
+  }
+  set wikiUrl(value) {
+    this.dispatchString(46, value);
+  }
+  getWikiUrl(lang) {
+    return this.getProp(46, lang);
+  }
+  setWikiUrl(value, lang) {
+    this.dispatchString(46, value, lang);
+  }
+  get isniId() {
+    return this.getProp(47) ?? null;
+  }
+  set isniId(value) {
+    this.dispatchString(47, value ?? "");
+  }
+  getIsniId(lang) {
+    return this.getProp(47, lang) ?? null;
+  }
+  setIsniId(value, lang) {
+    this.dispatchString(47, value ?? "", lang);
+  }
+  get orcidId() {
+    return this.getProp(48) ?? null;
+  }
+  set orcidId(value) {
+    this.dispatchString(48, value ?? "");
+  }
+  getOrcidId(lang) {
+    return this.getProp(48, lang) ?? null;
+  }
+  setOrcidId(value, lang) {
+    this.dispatchString(48, value ?? "", lang);
+  }
+  get inAuthorOfIds() {
+    return Array.from(this._in.get(2).values());
+  }
+  get inAuthorOf() {
+    return this.inAuthorOfIds.map((id) => Book.Load(id));
+  }
+  isInAuthorOf(id) {
+    return this._in.get(2).has(id);
+  }
+  addIntoAuthorOf(id) {
+    if (this.isInAuthorOf(id)) return;
+    const op = {
+      operation: PatchOperation.EditRelation,
+      objectType: Book.type,
+      objectId: id,
+      langId: 0,
+      relationId: 1,
+      // canonical: Book.authors
+      action: PatchAction.Add,
+      targetId: this.id
+    };
+    if (hasRecord(Book.type, id)) {
+      getRecord(Book.type, id).patch(op);
+    }
+    this.applyRelationRaw("in", 2, PatchAction.Add, id);
+    PatchInstance.addPatch(op);
+  }
+  removeFromAuthorOf(id) {
+    if (!this.isInAuthorOf(id)) return;
+    const op = {
+      operation: PatchOperation.EditRelation,
+      objectType: Book.type,
+      objectId: id,
+      langId: 0,
+      relationId: 1,
+      // canonical: Book.authors
+      action: PatchAction.Remove,
+      targetId: this.id
+    };
+    if (hasRecord(Book.type, id)) {
+      getRecord(Book.type, id).patch(op);
+    }
+    this.applyRelationRaw("in", 2, PatchAction.Remove, id);
+    PatchInstance.addPatch(op);
+  }
+  // ── UID methods ─────────────────────────────────────────────────────────
+  toPID() {
+    const scope = this.id & 2147483648 ? "U" : "C";
+    return `DL:${scope}:PR:${encodePID("PR", this.id)}`;
+  }
+  toNativePID() {
+    return this.toPID();
+  }
+  static fromPID(pid) {
+    try {
+      if (!pid.startsWith("DL:")) return decodePID("PR", pid);
+      const parts = pid.split(":");
+      if (parts.length >= 4 && parts[2] === "PR") {
+        return decodePID("PR", parts[3]);
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  // ── Inherited from isni standard ───────────────────────────────────────
+  get isniNormalized() {
+    return this.isniId ? ISNIAdapter.normalize(this.isniId) : null;
+  }
+  validateIsni() {
+    return ISNIAdapter.validate(this.isniId);
+  }
+  // ── Inherited from orcid standard ───────────────────────────────────────
+  get orcidNormalized() {
+    return this.orcidId ? ORCIDAdapter.normalize(this.orcidId) : null;
+  }
+  validateOrcid() {
+    return ORCIDAdapter.validate(this.orcidId);
+  }
+  sfcuid() {
+    if (this.isniId) return `isni:${ISNIAdapter.normalize(this.isniId)}`;
+    if (this.orcidId) return `orcid:${ORCIDAdapter.normalize(this.orcidId)}`;
+    return this.toNativePID();
+  }
+  get identityCluster() {
+    const primary = this.sfcuid();
+    const allAliases = [
+      this.isniId ? `isni:${ISNIAdapter.normalize(this.isniId)}` : null,
+      this.orcidId ? `orcid:${ORCIDAdapter.normalize(this.orcidId)}` : null,
+      this.toNativePID()
+    ].filter(Boolean);
+    return {
+      sfcuid: primary,
+      native: this.toNativePID(),
+      aliases: allAliases.filter((a) => a !== primary),
+      wireId: this.id
+    };
+  }
+  // Merge methods are now implemented in Orm using the schema definition.
+};
+_Person.type = 1;
+_Person.UID_STRATEGY = "standards-first";
+_Person.STANDARD_PRIORITY = ["isni", "orcid"];
+_Person.serializeSlim = serializePersonSlim;
+_Person.serializeExtended = serializePersonExtended;
+_Person.serializeProv = serializePersonProv;
+var Person = _Person;
+var NewPersonWithId = (id, creatorUsername) => {
+  if (hasRecord(Person.type, id, creatorUsername)) {
+    return getRecord(Person.type, id, creatorUsername);
+  }
+  const record = new Person(Person.createNewRequest(id), creatorUsername);
+  addRecord(Person.type, record, creatorUsername);
+  return record;
+};
+
+// ../standard-adapters/dist/chunk-VP4ER7MD.js
+var LCCAdapter = {
+  standardId: "lcc",
+  uriScheme: "LCC",
+  normalize(value) {
+    return value.trim();
+  },
+  display(value) {
+    return LCCAdapter.normalize(value);
+  },
+  validate(value) {
+    if (!value) return { valid: false, error: "LCC notation is absent" };
+    const normalized = LCCAdapter.normalize(value);
+    if (!/^[A-Z0-9\.\s]+$/.test(normalized))
+      return { valid: false, error: `LCC notation does not match pattern: ${normalized}` };
+    return { valid: true };
+  },
+  toLinkedDataUri(value) {
+    return `https://id.loc.gov/authorities/classification/${LCCAdapter.normalize(value)}`;
+  },
+  apis: {}
+};
+
+// ../standard-adapters/dist/chunk-AHIDYNLW.js
+var DDCAdapter = {
+  standardId: "ddc",
+  uriScheme: "DDC",
+  normalize(value) {
+    let trimmed = value.trim();
+    if (trimmed.includes(".")) trimmed = trimmed.replace(/\.?0+$/, "");
+    return trimmed;
+  },
+  display(value) {
+    return DDCAdapter.normalize(value);
+  },
+  validate(value) {
+    if (!value) return { valid: false, error: "DDC notation is absent" };
+    const normalized = DDCAdapter.normalize(value);
+    if (!/^[0-9]{3}(\.[0-9]+)?$/.test(normalized))
+      return { valid: false, error: `DDC notation does not match pattern: ${normalized}` };
+    return { valid: true };
+  },
+  toLinkedDataUri(value) {
+    return `https://id.loc.gov/authorities/classification/${DDCAdapter.normalize(value)}`;
+  },
+  apis: {}
+};
+
+// ../standard-adapters/dist/chunk-C5WHAJXI.js
+var UDCAdapter = {
+  standardId: "udc",
+  uriScheme: "UDC",
+  normalize(value) {
+    return value.trim();
+  },
+  display(value) {
+    return UDCAdapter.normalize(value);
+  },
+  validate(value) {
+    if (!value) return { valid: false, error: "UDC notation is absent" };
+    const normalized = UDCAdapter.normalize(value);
+    if (!/^[0-9\.\-\:\+\/\(\)\[\]\=\*\"\s]+$/.test(normalized))
+      return { valid: false, error: `UDC notation does not match pattern: ${normalized}` };
+    return { valid: true };
+  },
+  toLinkedDataUri(value) {
+    return `https://udcsummary.info/php/index.php?c=${UDCAdapter.normalize(value)}`;
+  },
+  apis: {}
+};
+
+// ../standard-adapters/dist/chunk-IJYCM5NU.js
+var CLCAdapter = {
+  standardId: "clc",
+  uriScheme: "CLC",
+  normalize(value) {
+    return value.trim();
+  },
+  display(value) {
+    return CLCAdapter.normalize(value);
+  },
+  validate(value) {
+    if (!value) return { valid: false, error: "CLC notation is absent" };
+    const normalized = CLCAdapter.normalize(value);
+    if (!/^[A-Z0-9\.\-\+\=\s]+$/.test(normalized))
+      return { valid: false, error: `CLC notation does not match pattern: ${normalized}` };
+    return { valid: true };
+  },
+  toLinkedDataUri(value) {
+    return `https://clc.nlc.cn/${CLCAdapter.normalize(value)}`;
+  },
+  apis: {}
+};
+
+// ../standard-adapters/dist/chunk-INW2BUCX.js
+var BBKAdapter = {
+  standardId: "bbk",
+  uriScheme: "BBK",
+  normalize(value) {
+    return value.trim();
+  },
+  display(value) {
+    return BBKAdapter.normalize(value);
+  },
+  validate(value) {
+    if (!value) return { valid: false, error: "BBK notation is absent" };
+    const normalized = BBKAdapter.normalize(value);
+    if (!/^[0-9А-Яа-яA-Za-z\.\-\s]+$/.test(normalized))
+      return { valid: false, error: `BBK notation does not match pattern: ${normalized}` };
+    return { valid: true };
+  },
+  toLinkedDataUri(value) {
+    return `https://bbk.rsl.ru/external/${BBKAdapter.normalize(value)}`;
+  },
+  apis: {}
+};
+
+// ../standard-adapters/dist/chunk-D5QOJWWA.js
+var TLCAdapter = {
+  standardId: "tlc",
+  uriScheme: "TLC",
+  normalize(value) {
+    return value.trim();
+  },
+  display(value) {
+    return TLCAdapter.normalize(value);
+  },
+  validate(value) {
+    if (!value) return { valid: false, error: "TLC notation is absent" };
+    const normalized = TLCAdapter.normalize(value);
+    if (!/^[A-Z0-9\.\-\s]+$/.test(normalized))
+      return { valid: false, error: `TLC notation does not match pattern: ${normalized}` };
+    return { valid: true };
+  },
+  toLinkedDataUri(value) {
+    return `https://nlt.go.th/tlc/${TLCAdapter.normalize(value)}`;
+  },
+  apis: {}
+};
+
+// ../standard-adapters/dist/chunk-KOHT5EA3.js
+var CCAdapter = {
+  standardId: "cc",
+  uriScheme: "CC",
+  normalize(value) {
+    return value.trim();
+  },
+  display(value) {
+    return CCAdapter.normalize(value);
+  },
+  validate(value) {
+    if (!value) return { valid: false, error: "CC notation is absent" };
+    const normalized = CCAdapter.normalize(value);
+    if (!/^[A-Za-z0-9\:\,\;\-\.\'\s]+$/.test(normalized))
+      return { valid: false, error: `CC notation does not match pattern: ${normalized}` };
+    return { valid: true };
+  },
+  toLinkedDataUri(value) {
+    return `https://isko.org/cc/${CCAdapter.normalize(value)}`;
+  },
+  apis: {}
+};
+
+// src/models/generated-src/Tag.ts
+var schema2 = schemas["Tag"];
+Registry.register(schema2);
+var TAG_PROP_IDS = { title: 0, description: 1, originalLang: 2, ageGradeBand: 3, previewTxId: 4, safe: 5, deleted: 6, lifecycleStatus: 7, lccNotation: 50, ddcNotation: 49, udcNotation: 51, clcNotation: 52, bbkNotation: 53, tlcNotation: 54, ccNotation: 55 };
+function serializeTagSlim(records) {
+  return commonSerializeSlim(schema2, records, currentLayout());
+}
+function serializeTagExtended(records) {
+  return commonSerializeExtended(schema2, records, currentLayout());
+}
+function serializeTagProv(records) {
+  return commonSerializeProv(schema2, records);
+}
+var _Tag = class _Tag extends Orm {
+  constructor(json, creatorUsername) {
+    super(_Tag.type, json, creatorUsername);
+  }
+  /** Synchronous LRU read — throws on miss (use LoadAsync to re-hydrate). */
+  static Load(id, creatorUsername) {
+    return getRecord(_Tag.type, id, creatorUsername);
+  }
+  static Has(id, creatorUsername) {
+    return hasRecord(_Tag.type, id, creatorUsername);
+  }
+  /** On-demand hydration from the worker after LRU eviction (SPEC §2.5). */
+  static async LoadAsync(id, creatorUsername) {
+    if (hasRecord(_Tag.type, id, creatorUsername)) {
+      return getRecord(_Tag.type, id, creatorUsername);
+    }
+    const thread = PatchInstance.threadInstance;
+    if (!thread) throw new Error("worker thread not initialized \u2014 call PatchInstance.initThread first");
+    const res = await thread.sendRequest({
+      cmd: "getRecord" /* GetRecord */,
+      payload: { objectType: _Tag.type, id }
+    });
+    if (!res || res.length === 0) throw new Error(`Tag ${id} not found in worker storage`);
+    const record = NewTagWithId(id, creatorUsername);
+    for (const data of res) {
+      if (data.slim) record.mergeSlim(data.slim, 0, data.lang);
+      if (data.extended) record.mergeExtended(data.extended, 0, data.lang);
+      if (data.prov) record.mergeProv(data.prov, 0, data.lang);
+    }
+    return record;
+  }
+  get lccNotation() {
+    return this.getProp(50) ?? null;
+  }
+  set lccNotation(value) {
+    this.dispatchString(50, value ?? "");
+  }
+  getLccNotation(lang) {
+    return this.getProp(50, lang) ?? null;
+  }
+  setLccNotation(value, lang) {
+    this.dispatchString(50, value ?? "", lang);
+  }
+  get ddcNotation() {
+    return this.getProp(49) ?? null;
+  }
+  set ddcNotation(value) {
+    this.dispatchString(49, value ?? "");
+  }
+  getDdcNotation(lang) {
+    return this.getProp(49, lang) ?? null;
+  }
+  setDdcNotation(value, lang) {
+    this.dispatchString(49, value ?? "", lang);
+  }
+  get udcNotation() {
+    return this.getProp(51) ?? null;
+  }
+  set udcNotation(value) {
+    this.dispatchString(51, value ?? "");
+  }
+  getUdcNotation(lang) {
+    return this.getProp(51, lang) ?? null;
+  }
+  setUdcNotation(value, lang) {
+    this.dispatchString(51, value ?? "", lang);
+  }
+  get clcNotation() {
+    return this.getProp(52) ?? null;
+  }
+  set clcNotation(value) {
+    this.dispatchString(52, value ?? "");
+  }
+  getClcNotation(lang) {
+    return this.getProp(52, lang) ?? null;
+  }
+  setClcNotation(value, lang) {
+    this.dispatchString(52, value ?? "", lang);
+  }
+  get bbkNotation() {
+    return this.getProp(53) ?? null;
+  }
+  set bbkNotation(value) {
+    this.dispatchString(53, value ?? "");
+  }
+  getBbkNotation(lang) {
+    return this.getProp(53, lang) ?? null;
+  }
+  setBbkNotation(value, lang) {
+    this.dispatchString(53, value ?? "", lang);
+  }
+  get tlcNotation() {
+    return this.getProp(54) ?? null;
+  }
+  set tlcNotation(value) {
+    this.dispatchString(54, value ?? "");
+  }
+  getTlcNotation(lang) {
+    return this.getProp(54, lang) ?? null;
+  }
+  setTlcNotation(value, lang) {
+    this.dispatchString(54, value ?? "", lang);
+  }
+  get ccNotation() {
+    return this.getProp(55) ?? null;
+  }
+  set ccNotation(value) {
+    this.dispatchString(55, value ?? "");
+  }
+  getCcNotation(lang) {
+    return this.getProp(55, lang) ?? null;
+  }
+  setCcNotation(value, lang) {
+    this.dispatchString(55, value ?? "", lang);
+  }
+  get inTagsIds() {
+    return Array.from(this._in.get(0).values());
+  }
+  get inTags() {
+    return this.inTagsIds.map((id) => _Tag.Load(id));
+  }
+  isInTag(id) {
+    return this._in.get(0).has(id);
+  }
+  addIntoTag(id) {
+    if (this.isInTag(id)) return;
+    const op = {
+      operation: PatchOperation.EditRelation,
+      objectType: _Tag.type,
+      objectId: id,
+      langId: 0,
+      relationId: 3,
+      // canonical: Tag.tags
+      action: PatchAction.Add,
+      targetId: this.id
+    };
+    if (hasRecord(_Tag.type, id)) {
+      getRecord(_Tag.type, id).patch(op);
+    }
+    this.applyRelationRaw("in", 0, PatchAction.Add, id);
+    PatchInstance.addPatch(op);
+  }
+  removeFromTag(id) {
+    if (!this.isInTag(id)) return;
+    const op = {
+      operation: PatchOperation.EditRelation,
+      objectType: _Tag.type,
+      objectId: id,
+      langId: 0,
+      relationId: 3,
+      // canonical: Tag.tags
+      action: PatchAction.Remove,
+      targetId: this.id
+    };
+    if (hasRecord(_Tag.type, id)) {
+      getRecord(_Tag.type, id).patch(op);
+    }
+    this.applyRelationRaw("in", 0, PatchAction.Remove, id);
+    PatchInstance.addPatch(op);
+  }
+  get tagsIds() {
+    return Array.from(this._has.get(3).values());
+  }
+  get tags() {
+    return this.tagsIds.map((id) => _Tag.Load(id));
+  }
+  hasTag(id) {
+    return this._has.get(3).has(id);
+  }
+  addTag(id) {
+    if (this.hasTag(id)) return;
+    this.dispatchRelation(3, PatchAction.Add, id);
+  }
+  removeTag(id) {
+    if (!this.hasTag(id)) return;
+    this.dispatchRelation(3, PatchAction.Remove, id);
+  }
+  get booksIds() {
+    return Array.from(this._has.get(4).values());
+  }
+  get books() {
+    return this.booksIds.map((id) => Book.Load(id));
+  }
+  hasBook(id) {
+    return this._has.get(4).has(id);
+  }
+  addBook(id) {
+    if (this.hasBook(id)) return;
+    this.dispatchRelation(4, PatchAction.Add, id);
+  }
+  removeBook(id) {
+    if (!this.hasBook(id)) return;
+    this.dispatchRelation(4, PatchAction.Remove, id);
+  }
+  // ── UID methods ─────────────────────────────────────────────────────────
+  toPID() {
+    const scope = this.id & 2147483648 ? "U" : "C";
+    return `DL:${scope}:TG:${encodePID("TG", this.id)}`;
+  }
+  toNativePID() {
+    return this.toPID();
+  }
+  static fromPID(pid) {
+    try {
+      if (!pid.startsWith("DL:")) return decodePID("TG", pid);
+      const parts = pid.split(":");
+      if (parts.length >= 4 && parts[2] === "TG") {
+        return decodePID("TG", parts[3]);
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  // ── Inherited from lcc standard ───────────────────────────────────────
+  get lccNormalized() {
+    return this.lccNotation ? LCCAdapter.normalize(this.lccNotation) : null;
+  }
+  validateLcc() {
+    return LCCAdapter.validate(this.lccNotation);
+  }
+  // ── Inherited from ddc standard ───────────────────────────────────────
+  get ddcNormalized() {
+    return this.ddcNotation ? DDCAdapter.normalize(this.ddcNotation) : null;
+  }
+  validateDdc() {
+    return DDCAdapter.validate(this.ddcNotation);
+  }
+  // ── Inherited from udc standard ───────────────────────────────────────
+  get udcNormalized() {
+    return this.udcNotation ? UDCAdapter.normalize(this.udcNotation) : null;
+  }
+  validateUdc() {
+    return UDCAdapter.validate(this.udcNotation);
+  }
+  // ── Inherited from clc standard ───────────────────────────────────────
+  get clcNormalized() {
+    return this.clcNotation ? CLCAdapter.normalize(this.clcNotation) : null;
+  }
+  validateClc() {
+    return CLCAdapter.validate(this.clcNotation);
+  }
+  // ── Inherited from bbk standard ───────────────────────────────────────
+  get bbkNormalized() {
+    return this.bbkNotation ? BBKAdapter.normalize(this.bbkNotation) : null;
+  }
+  validateBbk() {
+    return BBKAdapter.validate(this.bbkNotation);
+  }
+  // ── Inherited from tlc standard ───────────────────────────────────────
+  get tlcNormalized() {
+    return this.tlcNotation ? TLCAdapter.normalize(this.tlcNotation) : null;
+  }
+  validateTlc() {
+    return TLCAdapter.validate(this.tlcNotation);
+  }
+  // ── Inherited from cc standard ───────────────────────────────────────
+  get ccNormalized() {
+    return this.ccNotation ? CCAdapter.normalize(this.ccNotation) : null;
+  }
+  validateCc() {
+    return CCAdapter.validate(this.ccNotation);
+  }
+  sfcuid() {
+    if (this.lccNotation) return `lcc:${LCCAdapter.normalize(this.lccNotation)}`;
+    if (this.ddcNotation) return `ddc:${DDCAdapter.normalize(this.ddcNotation)}`;
+    if (this.udcNotation) return `udc:${UDCAdapter.normalize(this.udcNotation)}`;
+    if (this.clcNotation) return `clc:${CLCAdapter.normalize(this.clcNotation)}`;
+    if (this.bbkNotation) return `bbk:${BBKAdapter.normalize(this.bbkNotation)}`;
+    if (this.tlcNotation) return `tlc:${TLCAdapter.normalize(this.tlcNotation)}`;
+    if (this.ccNotation) return `cc:${CCAdapter.normalize(this.ccNotation)}`;
+    return this.toNativePID();
+  }
+  get identityCluster() {
+    const primary = this.sfcuid();
+    const allAliases = [
+      this.lccNotation ? `lcc:${LCCAdapter.normalize(this.lccNotation)}` : null,
+      this.ddcNotation ? `ddc:${DDCAdapter.normalize(this.ddcNotation)}` : null,
+      this.udcNotation ? `udc:${UDCAdapter.normalize(this.udcNotation)}` : null,
+      this.clcNotation ? `clc:${CLCAdapter.normalize(this.clcNotation)}` : null,
+      this.bbkNotation ? `bbk:${BBKAdapter.normalize(this.bbkNotation)}` : null,
+      this.tlcNotation ? `tlc:${TLCAdapter.normalize(this.tlcNotation)}` : null,
+      this.ccNotation ? `cc:${CCAdapter.normalize(this.ccNotation)}` : null,
+      this.toNativePID()
+    ].filter(Boolean);
+    return {
+      sfcuid: primary,
+      native: this.toNativePID(),
+      aliases: allAliases.filter((a) => a !== primary),
+      wireId: this.id
+    };
+  }
+  // Merge methods are now implemented in Orm using the schema definition.
+};
+_Tag.type = 2;
+_Tag.UID_STRATEGY = "standards-first";
+_Tag.STANDARD_PRIORITY = ["lcc", "ddc", "udc", "clc", "bbk", "tlc", "cc"];
+_Tag.serializeSlim = serializeTagSlim;
+_Tag.serializeExtended = serializeTagExtended;
+_Tag.serializeProv = serializeTagProv;
+var Tag = _Tag;
+var NewTagWithId = (id, creatorUsername) => {
+  if (hasRecord(Tag.type, id, creatorUsername)) {
+    return getRecord(Tag.type, id, creatorUsername);
+  }
+  const record = new Tag(Tag.createNewRequest(id), creatorUsername);
+  addRecord(Tag.type, record, creatorUsername);
+  return record;
+};
+
+// ../standard-adapters/dist/chunk-3OK4JVCA.js
+var _keys = /* @__PURE__ */ new Map();
+var apiKeyDictionary = {
+  set(apiId, value) {
+    if (!value) throw new Error(`[apiKeyDictionary] Empty value passed for apiId "${apiId}".`);
+    _keys.set(apiId, value);
+  },
+  get(apiId) {
+    return _keys.get(apiId);
+  },
+  require(apiId) {
+    const key = _keys.get(apiId);
+    if (!key) throw new Error(
+      `[${apiId}] API key is not configured. Call apiKeyDictionary.set("${apiId}", "<your-key>") before using this adapter.`
+    );
+    return key;
+  }
+};
+function validateISBN13Luhn(isbn13) {
+  if (isbn13.length !== 13) return { valid: false, error: `Expected 13 digits, got ${isbn13.length}` };
+  let sum = 0;
+  for (let i = 0; i < 12; i++) sum += parseInt(isbn13[i], 10) * (i % 2 === 0 ? 1 : 3);
+  const expected = (10 - sum % 10) % 10;
+  if (expected !== parseInt(isbn13[12], 10))
+    return { valid: false, error: `Check digit mismatch: expected ${expected}, got ${isbn13[12]}` };
+  return { valid: true };
+}
+var ISBNAdapter = {
+  standardId: "isbn",
+  uriScheme: "ISBN",
+  normalize(value) {
+    const digits = value.replace(/[\s-]/g, "");
+    if (digits.length === 10) {
+      const base = "978" + digits.slice(0, 9);
+      let sum = 0;
+      for (let i = 0; i < 12; i++) sum += parseInt(base[i], 10) * (i % 2 === 0 ? 1 : 3);
+      return base + (10 - sum % 10) % 10;
+    }
+    return digits;
+  },
+  display(value) {
+    const n = ISBNAdapter.normalize(value);
+    if (n.length === 13) return `${n.slice(0, 3)}-${n[3]}-${n.slice(4, 7)}-${n.slice(7, 12)}-${n[12]}`;
+    return n;
+  },
+  validate(value) {
+    if (!value) return { valid: false, error: "ISBN is absent" };
+    const normalized = ISBNAdapter.normalize(value);
+    if (!/^97[89][0-9]{10}$/.test(normalized))
+      return { valid: false, error: `ISBN does not match pattern: ${normalized}` };
+    return validateISBN13Luhn(normalized);
+  },
+  toLinkedDataUri(value) {
+    return `urn:isbn:${ISBNAdapter.normalize(value)}`;
+  },
+  apis: {
+    openlibrary: {
+      apiId: "openlibrary",
+      name: "Open Library Books API",
+      async fetch({ isbn }) {
+        if (!isbn) return {};
+        const res = await fetch(
+          `https://openlibrary.org/api/books?bibkeys=ISBN:${isbn}&format=json&jscmd=data`
+        );
+        if (!res.ok) return {};
+        const data = await res.json();
+        const book = data[`ISBN:${isbn}`] ?? {};
+        return {
+          title: book.title,
+          authors: book.authors?.map((a) => a.name),
+          publishDate: book.publish_date,
+          pageCount: book.number_of_pages,
+          coverUrl: book.cover?.medium,
+          description: book.excerpts?.[0]?.text
+        };
+      }
+    },
+    googlebooks: {
+      apiId: "googlebooks",
+      name: "Google Books API",
+      async fetch({ isbn }) {
+        if (!isbn) return {};
+        const key = apiKeyDictionary.require("googlebooks");
+        const res = await fetch(
+          `https://www.googleapis.com/books/v1/volumes?q=isbn:${isbn}&key=${key}`
+        );
+        if (!res.ok) return {};
+        const data = await res.json();
+        const info = data.items?.[0]?.volumeInfo ?? {};
+        return {
+          title: info.title,
+          authors: info.authors,
+          publishedDate: info.publishedDate,
+          pageCount: info.pageCount,
+          language: info.language,
+          description: info.description,
+          thumbnail: info.imageLinks?.thumbnail
+        };
+      }
+    }
+  }
+};
+
+// src/models/generated-src/Book.ts
+var schema3 = schemas["Book"];
+Registry.register(schema3);
+var BOOK_PROP_IDS = { title: 0, description: 1, originalLang: 2, ageGradeBand: 3, previewTxId: 4, safe: 5, deleted: 6, lifecycleStatus: 7, prerequisites: 8, deweyDecimal: 9, locCallNumber: 10, copyrightStatus: 11, textQuality: 12, illustrations: 13, educationQuality: 14, practicality: 15, accessibilityLevel: 16, teacherMaterials: 17, pedagogicalScaffolding: 18, clarityOfExplanation: 19, workedExamples: 20, exercisesAndAssessment: 21, selfStudyReadiness: 22, referenceApparatus: 23, safetyGuidance: 24, contentCurrency: 25, ecoRegeneration: 26, communityLiving: 27, promotesPeace: 28, businessDevelopment: 29, language: 30, downloadTxId: 31, method: 32, isAiTranslation: 33, aiEngine: 34, addedAt: 35, nbPages: 36, sizeBytes: 37, publisher: 38, publicationDate: 39, publishedAt: 40, qualityScore: 41, isbn: 42 };
+function serializeBookSlim(records) {
+  return commonSerializeSlim(schema3, records, currentLayout());
+}
+function serializeBookExtended(records) {
+  return commonSerializeExtended(schema3, records, currentLayout());
+}
+function serializeBookProv(records) {
+  return commonSerializeProv(schema3, records);
+}
+var _Book = class _Book extends Orm {
+  constructor(json, creatorUsername) {
+    super(_Book.type, json, creatorUsername);
+  }
+  /** Synchronous LRU read — throws on miss (use LoadAsync to re-hydrate). */
+  static Load(id, creatorUsername) {
+    return getRecord(_Book.type, id, creatorUsername);
+  }
+  static Has(id, creatorUsername) {
+    return hasRecord(_Book.type, id, creatorUsername);
+  }
+  /** On-demand hydration from the worker after LRU eviction (SPEC §2.5). */
+  static async LoadAsync(id, creatorUsername) {
+    if (hasRecord(_Book.type, id, creatorUsername)) {
+      return getRecord(_Book.type, id, creatorUsername);
+    }
+    const thread = PatchInstance.threadInstance;
+    if (!thread) throw new Error("worker thread not initialized \u2014 call PatchInstance.initThread first");
+    const res = await thread.sendRequest({
+      cmd: "getRecord" /* GetRecord */,
+      payload: { objectType: _Book.type, id }
+    });
+    if (!res || res.length === 0) throw new Error(`Book ${id} not found in worker storage`);
+    const record = NewBookWithId(id, creatorUsername);
+    for (const data of res) {
+      if (data.slim) record.mergeSlim(data.slim, 0, data.lang);
+      if (data.extended) record.mergeExtended(data.extended, 0, data.lang);
+      if (data.prov) record.mergeProv(data.prov, 0, data.lang);
+    }
+    return record;
+  }
+  get prerequisites() {
+    return this.getProp(8);
+  }
+  set prerequisites(value) {
+    this.dispatchString(8, value);
+  }
+  getPrerequisites(lang) {
+    return this.getProp(8, lang);
+  }
+  setPrerequisites(value, lang) {
+    this.dispatchString(8, value, lang);
+  }
+  get deweyDecimal() {
+    return this.getProp(9);
+  }
+  set deweyDecimal(value) {
+    this.dispatchString(9, value);
+  }
+  getDeweyDecimal(lang) {
+    return this.getProp(9, lang);
+  }
+  setDeweyDecimal(value, lang) {
+    this.dispatchString(9, value, lang);
+  }
+  get locCallNumber() {
+    return this.getProp(10);
+  }
+  set locCallNumber(value) {
+    this.dispatchString(10, value);
+  }
+  getLocCallNumber(lang) {
+    return this.getProp(10, lang);
+  }
+  setLocCallNumber(value, lang) {
+    this.dispatchString(10, value, lang);
+  }
+  get copyrightStatus() {
+    return this.getProp(11) ?? 0;
+  }
+  set copyrightStatus(value) {
+    this.dispatchNumber(11, value);
+  }
+  getCopyrightStatus(lang) {
+    return this.getProp(11, lang) ?? 0;
+  }
+  setCopyrightStatus(value, lang) {
+    this.dispatchNumber(11, value, lang);
+  }
+  get textQuality() {
+    return this.getProp(12) ?? 0;
+  }
+  set textQuality(value) {
+    this.dispatchNumber(12, value);
+  }
+  getTextQuality(lang) {
+    return this.getProp(12, lang) ?? 0;
+  }
+  setTextQuality(value, lang) {
+    this.dispatchNumber(12, value, lang);
+  }
+  get illustrations() {
+    return this.getProp(13) ?? 0;
+  }
+  set illustrations(value) {
+    this.dispatchNumber(13, value);
+  }
+  getIllustrations(lang) {
+    return this.getProp(13, lang) ?? 0;
+  }
+  setIllustrations(value, lang) {
+    this.dispatchNumber(13, value, lang);
+  }
+  get educationQuality() {
+    return this.getProp(14) ?? 0;
+  }
+  set educationQuality(value) {
+    this.dispatchNumber(14, value);
+  }
+  getEducationQuality(lang) {
+    return this.getProp(14, lang) ?? 0;
+  }
+  setEducationQuality(value, lang) {
+    this.dispatchNumber(14, value, lang);
+  }
+  get practicality() {
+    return this.getProp(15) ?? 0;
+  }
+  set practicality(value) {
+    this.dispatchNumber(15, value);
+  }
+  getPracticality(lang) {
+    return this.getProp(15, lang) ?? 0;
+  }
+  setPracticality(value, lang) {
+    this.dispatchNumber(15, value, lang);
+  }
+  get accessibilityLevel() {
+    return this.getProp(16) ?? 0;
+  }
+  set accessibilityLevel(value) {
+    this.dispatchNumber(16, value);
+  }
+  getAccessibilityLevel(lang) {
+    return this.getProp(16, lang) ?? 0;
+  }
+  setAccessibilityLevel(value, lang) {
+    this.dispatchNumber(16, value, lang);
+  }
+  get teacherMaterials() {
+    return this.getProp(17) ?? false;
+  }
+  set teacherMaterials(value) {
+    this.dispatchNumber(17, value ? 1 : 0);
+  }
+  getTeacherMaterials(lang) {
+    return this.getProp(17, lang) ?? false;
+  }
+  setTeacherMaterials(value, lang) {
+    this.dispatchNumber(17, value ? 1 : 0, lang);
+  }
+  get pedagogicalScaffolding() {
+    return this.getProp(18) ?? 0;
+  }
+  set pedagogicalScaffolding(value) {
+    this.dispatchNumber(18, value);
+  }
+  getPedagogicalScaffolding(lang) {
+    return this.getProp(18, lang) ?? 0;
+  }
+  setPedagogicalScaffolding(value, lang) {
+    this.dispatchNumber(18, value, lang);
+  }
+  get clarityOfExplanation() {
+    return this.getProp(19) ?? 0;
+  }
+  set clarityOfExplanation(value) {
+    this.dispatchNumber(19, value);
+  }
+  getClarityOfExplanation(lang) {
+    return this.getProp(19, lang) ?? 0;
+  }
+  setClarityOfExplanation(value, lang) {
+    this.dispatchNumber(19, value, lang);
+  }
+  get workedExamples() {
+    return this.getProp(20) ?? 0;
+  }
+  set workedExamples(value) {
+    this.dispatchNumber(20, value);
+  }
+  getWorkedExamples(lang) {
+    return this.getProp(20, lang) ?? 0;
+  }
+  setWorkedExamples(value, lang) {
+    this.dispatchNumber(20, value, lang);
+  }
+  get exercisesAndAssessment() {
+    return this.getProp(21) ?? 0;
+  }
+  set exercisesAndAssessment(value) {
+    this.dispatchNumber(21, value);
+  }
+  getExercisesAndAssessment(lang) {
+    return this.getProp(21, lang) ?? 0;
+  }
+  setExercisesAndAssessment(value, lang) {
+    this.dispatchNumber(21, value, lang);
+  }
+  get selfStudyReadiness() {
+    return this.getProp(22) ?? 0;
+  }
+  set selfStudyReadiness(value) {
+    this.dispatchNumber(22, value);
+  }
+  getSelfStudyReadiness(lang) {
+    return this.getProp(22, lang) ?? 0;
+  }
+  setSelfStudyReadiness(value, lang) {
+    this.dispatchNumber(22, value, lang);
+  }
+  get referenceApparatus() {
+    return this.getProp(23) ?? 0;
+  }
+  set referenceApparatus(value) {
+    this.dispatchNumber(23, value);
+  }
+  getReferenceApparatus(lang) {
+    return this.getProp(23, lang) ?? 0;
+  }
+  setReferenceApparatus(value, lang) {
+    this.dispatchNumber(23, value, lang);
+  }
+  get safetyGuidance() {
+    return this.getProp(24) ?? 0;
+  }
+  set safetyGuidance(value) {
+    this.dispatchNumber(24, value);
+  }
+  getSafetyGuidance(lang) {
+    return this.getProp(24, lang) ?? 0;
+  }
+  setSafetyGuidance(value, lang) {
+    this.dispatchNumber(24, value, lang);
+  }
+  get contentCurrency() {
+    return this.getProp(25) ?? 0;
+  }
+  set contentCurrency(value) {
+    this.dispatchNumber(25, value);
+  }
+  getContentCurrency(lang) {
+    return this.getProp(25, lang) ?? 0;
+  }
+  setContentCurrency(value, lang) {
+    this.dispatchNumber(25, value, lang);
+  }
+  get ecoRegeneration() {
+    return this.getProp(26) ?? 0;
+  }
+  set ecoRegeneration(value) {
+    this.dispatchNumber(26, value);
+  }
+  getEcoRegeneration(lang) {
+    return this.getProp(26, lang) ?? 0;
+  }
+  setEcoRegeneration(value, lang) {
+    this.dispatchNumber(26, value, lang);
+  }
+  get communityLiving() {
+    return this.getProp(27) ?? 0;
+  }
+  set communityLiving(value) {
+    this.dispatchNumber(27, value);
+  }
+  getCommunityLiving(lang) {
+    return this.getProp(27, lang) ?? 0;
+  }
+  setCommunityLiving(value, lang) {
+    this.dispatchNumber(27, value, lang);
+  }
+  get promotesPeace() {
+    return this.getProp(28) ?? 0;
+  }
+  set promotesPeace(value) {
+    this.dispatchNumber(28, value);
+  }
+  getPromotesPeace(lang) {
+    return this.getProp(28, lang) ?? 0;
+  }
+  setPromotesPeace(value, lang) {
+    this.dispatchNumber(28, value, lang);
+  }
+  get businessDevelopment() {
+    return this.getProp(29) ?? 0;
+  }
+  set businessDevelopment(value) {
+    this.dispatchNumber(29, value);
+  }
+  getBusinessDevelopment(lang) {
+    return this.getProp(29, lang) ?? 0;
+  }
+  setBusinessDevelopment(value, lang) {
+    this.dispatchNumber(29, value, lang);
+  }
+  get inTagsIds() {
+    return Array.from(this._in.get(0).values());
+  }
+  get inTags() {
+    return this.inTagsIds.map((id) => Tag.Load(id));
+  }
+  isInTag(id) {
+    return this._in.get(0).has(id);
+  }
+  addIntoTag(id) {
+    if (this.isInTag(id)) return;
+    const op = {
+      operation: PatchOperation.EditRelation,
+      objectType: Tag.type,
+      objectId: id,
+      langId: 0,
+      relationId: 4,
+      // canonical: Tag.books
+      action: PatchAction.Add,
+      targetId: this.id
+    };
+    if (hasRecord(Tag.type, id)) {
+      getRecord(Tag.type, id).patch(op);
+    }
+    this.applyRelationRaw("in", 0, PatchAction.Add, id);
+    PatchInstance.addPatch(op);
+  }
+  removeFromTag(id) {
+    if (!this.isInTag(id)) return;
+    const op = {
+      operation: PatchOperation.EditRelation,
+      objectType: Tag.type,
+      objectId: id,
+      langId: 0,
+      relationId: 4,
+      // canonical: Tag.books
+      action: PatchAction.Remove,
+      targetId: this.id
+    };
+    if (hasRecord(Tag.type, id)) {
+      getRecord(Tag.type, id).patch(op);
+    }
+    this.applyRelationRaw("in", 0, PatchAction.Remove, id);
+    PatchInstance.addPatch(op);
+  }
+  get authorsIds() {
+    return Array.from(this._has.get(1).values());
+  }
+  get authors() {
+    return this.authorsIds.map((id) => Person.Load(id));
+  }
+  hasAuthor(id) {
+    return this._has.get(1).has(id);
+  }
+  addAuthor(id) {
+    if (this.hasAuthor(id)) return;
+    this.dispatchRelation(1, PatchAction.Add, id);
+  }
+  removeAuthor(id) {
+    if (!this.hasAuthor(id)) return;
+    this.dispatchRelation(1, PatchAction.Remove, id);
+  }
+  getInstances(lang = Config.userLang) {
+    return this.getInstancesData(lang).map((data, i) => new BookInstance(this, lang, i, data));
+  }
+  getInstance(index, lang = Config.userLang) {
+    return this.getInstances(lang)[index];
+  }
+  getDefaultInstance(lang = Config.userLang) {
+    const instances = this.getInstances(lang);
+    return instances.find((i) => i.isDefault) ?? instances[0];
+  }
+  // ── UID methods ─────────────────────────────────────────────────────────
+  toPID() {
+    const scope = this.id & 2147483648 ? "U" : "C";
+    return `DL:${scope}:BK:${encodePID("BK", this.id)}`;
+  }
+  toNativePID() {
+    return this.toPID();
+  }
+  static fromPID(pid) {
+    try {
+      if (!pid.startsWith("DL:")) return decodePID("BK", pid);
+      const parts = pid.split(":");
+      if (parts.length >= 4 && parts[2] === "BK") {
+        return decodePID("BK", parts[3]);
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  // Merge methods are now implemented in Orm using the schema definition.
+  static async LoadInstance(pkValue, lang) {
+    const crosswalk = globalThis.ExternalIdCrosswalk?.instance;
+    if (!crosswalk) throw new Error("ExternalIdCrosswalk not initialized \u2014 bootup incomplete");
+    await crosswalk.whenReady();
+    if (pkValue.startsWith("DL:C:DERIVED:")) {
+      const result2 = await crosswalk.resolveDerived(pkValue, lang);
+      if (!result2) return null;
+      const record2 = await _Book.LoadAsync(result2.wireId);
+      return record2 ? { record: record2, instanceIndex: result2.instanceIndex } : null;
+    }
+    if (pkValue.startsWith("DL:C:")) {
+      const parsed = _Book.fromPID(pkValue);
+      if (parsed) {
+        const record2 = await _Book.LoadAsync(parsed.wireId);
+        return record2 ? { record: record2 } : null;
+      }
+      return null;
+    }
+    const colon = pkValue.indexOf(":");
+    if (colon === -1) return null;
+    const standardId = pkValue.slice(0, colon);
+    const value = pkValue.slice(colon + 1);
+    const result = await crosswalk.resolveForInstance(standardId, value, lang);
+    if (!result) return null;
+    const record = await _Book.LoadAsync(result.wireId);
+    return record ? { record, instanceIndex: result.instanceIndex } : null;
+  }
+};
+_Book.type = 0;
+_Book.UID_STRATEGY = "native-only";
+_Book.STANDARD_PRIORITY = [];
+_Book.serializeSlim = serializeBookSlim;
+_Book.serializeExtended = serializeBookExtended;
+_Book.serializeProv = serializeBookProv;
+var Book = _Book;
+var BookInstance = class {
+  constructor(parent, lang, index, data) {
+    this.parent = parent;
+    this.lang = lang;
+    this.index = index;
+    this.data = data;
+  }
+  get isDefault() {
+    return this.data["isDefault"] === true;
+  }
+  get language() {
+    return this.data["language"] ?? "";
+  }
+  set language(val) {
+    this.data["language"] = val;
+    const op = {
+      operation: PatchOperation.EditInstanceFieldString,
+      objectType: Book.type,
+      objectId: this.parent.id,
+      langId: LANG_ID_ENCODE[this.lang] ?? 0,
+      instanceIndex: this.index,
+      propertyId: 30,
+      // language — instanceField global propId
+      value: val ?? ""
+    };
+    this.parent.patch(op);
+    PatchInstance.addPatch(op);
+  }
+  get downloadTxId() {
+    return this.data["downloadTxId"] ?? "";
+  }
+  set downloadTxId(val) {
+    this.data["downloadTxId"] = val;
+    const op = {
+      operation: PatchOperation.EditInstanceFieldString,
+      objectType: Book.type,
+      objectId: this.parent.id,
+      langId: LANG_ID_ENCODE[this.lang] ?? 0,
+      instanceIndex: this.index,
+      propertyId: 31,
+      // downloadTxId — instanceField global propId
+      value: val ?? ""
+    };
+    this.parent.patch(op);
+    PatchInstance.addPatch(op);
+  }
+  get method() {
+    return this.data["method"] ?? 0;
+  }
+  set method(val) {
+    this.data["method"] = val;
+    const op = {
+      operation: PatchOperation.EditInstanceFieldNumber,
+      objectType: Book.type,
+      objectId: this.parent.id,
+      langId: LANG_ID_ENCODE[this.lang] ?? 0,
+      instanceIndex: this.index,
+      propertyId: 32,
+      // method — instanceField global propId
+      value: val
+    };
+    this.parent.patch(op);
+    PatchInstance.addPatch(op);
+  }
+  get isAiTranslation() {
+    return this.data["isAiTranslation"] ?? false;
+  }
+  set isAiTranslation(val) {
+    this.data["isAiTranslation"] = val;
+    const op = {
+      operation: PatchOperation.EditInstanceFieldNumber,
+      objectType: Book.type,
+      objectId: this.parent.id,
+      langId: LANG_ID_ENCODE[this.lang] ?? 0,
+      instanceIndex: this.index,
+      propertyId: 33,
+      // isAiTranslation — instanceField global propId
+      value: val ? 1 : 0
+    };
+    this.parent.patch(op);
+    PatchInstance.addPatch(op);
+  }
+  get aiEngine() {
+    return this.data["aiEngine"] ?? null;
+  }
+  set aiEngine(val) {
+    this.data["aiEngine"] = val;
+    const op = {
+      operation: PatchOperation.EditInstanceFieldString,
+      objectType: Book.type,
+      objectId: this.parent.id,
+      langId: LANG_ID_ENCODE[this.lang] ?? 0,
+      instanceIndex: this.index,
+      propertyId: 34,
+      // aiEngine — instanceField global propId
+      value: val ?? ""
+    };
+    this.parent.patch(op);
+    PatchInstance.addPatch(op);
+  }
+  get addedAt() {
+    return this.data["addedAt"] ?? 0;
+  }
+  set addedAt(val) {
+    this.data["addedAt"] = val;
+    const op = {
+      operation: PatchOperation.EditInstanceFieldNumber,
+      objectType: Book.type,
+      objectId: this.parent.id,
+      langId: LANG_ID_ENCODE[this.lang] ?? 0,
+      instanceIndex: this.index,
+      propertyId: 35,
+      // addedAt — instanceField global propId
+      value: val
+    };
+    this.parent.patch(op);
+    PatchInstance.addPatch(op);
+  }
+  get nbPages() {
+    return this.data["nbPages"] ?? 0;
+  }
+  set nbPages(val) {
+    this.data["nbPages"] = val;
+    const op = {
+      operation: PatchOperation.EditInstanceFieldNumber,
+      objectType: Book.type,
+      objectId: this.parent.id,
+      langId: LANG_ID_ENCODE[this.lang] ?? 0,
+      instanceIndex: this.index,
+      propertyId: 36,
+      // nbPages — instanceField global propId
+      value: val
+    };
+    this.parent.patch(op);
+    PatchInstance.addPatch(op);
+  }
+  get sizeBytes() {
+    return this.data["sizeBytes"] ?? 0;
+  }
+  set sizeBytes(val) {
+    this.data["sizeBytes"] = val;
+    const op = {
+      operation: PatchOperation.EditInstanceFieldNumber,
+      objectType: Book.type,
+      objectId: this.parent.id,
+      langId: LANG_ID_ENCODE[this.lang] ?? 0,
+      instanceIndex: this.index,
+      propertyId: 37,
+      // sizeBytes — instanceField global propId
+      value: val
+    };
+    this.parent.patch(op);
+    PatchInstance.addPatch(op);
+  }
+  get publisher() {
+    return this.data["publisher"] ?? null;
+  }
+  set publisher(val) {
+    this.data["publisher"] = val;
+    const op = {
+      operation: PatchOperation.EditInstanceFieldString,
+      objectType: Book.type,
+      objectId: this.parent.id,
+      langId: LANG_ID_ENCODE[this.lang] ?? 0,
+      instanceIndex: this.index,
+      propertyId: 38,
+      // publisher — instanceField global propId
+      value: val ?? ""
+    };
+    this.parent.patch(op);
+    PatchInstance.addPatch(op);
+  }
+  get publicationDate() {
+    return this.data["publicationDate"] ?? null;
+  }
+  set publicationDate(val) {
+    this.data["publicationDate"] = val;
+    const op = {
+      operation: PatchOperation.EditInstanceFieldString,
+      objectType: Book.type,
+      objectId: this.parent.id,
+      langId: LANG_ID_ENCODE[this.lang] ?? 0,
+      instanceIndex: this.index,
+      propertyId: 39,
+      // publicationDate — instanceField global propId
+      value: val ?? ""
+    };
+    this.parent.patch(op);
+    PatchInstance.addPatch(op);
+  }
+  get publishedAt() {
+    return this.data["publishedAt"] ?? null;
+  }
+  set publishedAt(val) {
+    this.data["publishedAt"] = val;
+    const op = {
+      operation: PatchOperation.EditInstanceFieldString,
+      objectType: Book.type,
+      objectId: this.parent.id,
+      langId: LANG_ID_ENCODE[this.lang] ?? 0,
+      instanceIndex: this.index,
+      propertyId: 40,
+      // publishedAt — instanceField global propId
+      value: val ?? ""
+    };
+    this.parent.patch(op);
+    PatchInstance.addPatch(op);
+  }
+  get qualityScore() {
+    return this.data["qualityScore"] ?? 0;
+  }
+  set qualityScore(val) {
+    this.data["qualityScore"] = val;
+    const op = {
+      operation: PatchOperation.EditInstanceFieldNumber,
+      objectType: Book.type,
+      objectId: this.parent.id,
+      langId: LANG_ID_ENCODE[this.lang] ?? 0,
+      instanceIndex: this.index,
+      propertyId: 41,
+      // qualityScore — instanceField global propId
+      value: val
+    };
+    this.parent.patch(op);
+    PatchInstance.addPatch(op);
+  }
+  get isbn() {
+    return this.data["isbn"] ?? null;
+  }
+  set isbn(val) {
+    this.data["isbn"] = val;
+    const op = {
+      operation: PatchOperation.EditInstanceFieldString,
+      objectType: Book.type,
+      objectId: this.parent.id,
+      langId: LANG_ID_ENCODE[this.lang] ?? 0,
+      instanceIndex: this.index,
+      propertyId: 42,
+      // isbn — instanceField global propId
+      value: val ?? ""
+    };
+    this.parent.patch(op);
+    PatchInstance.addPatch(op);
+  }
+  derivedSfcuid(sourceSfcuid) {
+    const parts = [
+      this.language ?? ""
+    ];
+    return `DL:C:DERIVED:${sourceSfcuid}:${parts.map((p) => encodeURIComponent(String(p))).join(":")}`;
+  }
+  // ── Inherited from isbn standard ───────────────────────────────────────
+  get isbnNormalized() {
+    return this.isbn ? ISBNAdapter.normalize(this.isbn) : null;
+  }
+  validateIsbn() {
+    return ISBNAdapter.validate(this.isbn);
+  }
+  sfcuid() {
+    if (this.isbn) return `isbn:${ISBNAdapter.normalize(this.isbn)}`;
+    return this.derivedSfcuid(this.parent.toPID());
+  }
+  get identityCluster() {
+    const primary = this.sfcuid();
+    const allAliases = [
+      this.isbn ? `isbn:${ISBNAdapter.normalize(this.isbn)}` : null,
+      this.parent.toPID()
+    ].filter(Boolean);
+    return {
+      sfcuid: primary,
+      native: this.parent.toPID(),
+      aliases: allAliases.filter((a) => a !== primary),
+      wireId: this.parent.id
+    };
+  }
+  // High-ease parent delegates
+  get description() {
+    return this.parent.getDescription(this.lang) ?? "";
+  }
+  set description(val) {
+    this.parent.setDescription(val, this.lang);
+  }
+};
+var NewBookWithId = (id, creatorUsername) => {
+  if (hasRecord(Book.type, id, creatorUsername)) {
+    return getRecord(Book.type, id, creatorUsername);
+  }
+  const record = new Book(Book.createNewRequest(id), creatorUsername);
+  addRecord(Book.type, record, creatorUsername);
+  return record;
+};
+
+// src/models/generated-src/index.ts
+var ModelTypes = {
+  [0]: Book,
+  [1]: Person,
+  [2]: Tag
+};
+
+export {
+  PatchOperation,
+  PatchAction,
+  LANG_ID_ENCODE,
+  LANG_ID_DECODE,
+  resolveLayout,
+  packPatch,
+  unpackPatch,
+  patchToEvm,
+  evmToPatch,
+  LANG_AGNOSTIC,
+  isEvmPatch,
+  inceptionDate,
+  DateUtils,
+  ActionTypes,
+  WorkerCommands,
+  Rating,
+  WorkerEvent,
+  DownloadState,
+  SidecarType,
+  versionsFile,
+  CURRENT_VERSION,
+  currentLayout,
+  debouncePromise,
+  Patches,
+  PatchInstance,
+  deserializePatches,
+  serializePatches,
+  getPatchInstanceByAccount,
+  PopulateStatsStore,
+  DownloadsByType,
+  VisitsByType,
+  FavoritesByTypes,
+  Stats,
+  addReactivitySystem,
+  setReactivitySystem,
+  dbReactivity,
+  LruCache,
+  configureDb,
+  clear,
+  dump,
+  getRecordKey,
+  hasRecord,
+  getRecord,
+  addRecord,
+  removeRecord,
+  pinRecord,
+  unpinRecord,
+  localRecordTable,
+  extractRecordCols,
+  relationColName2 as relationColName,
+  SchemaRegistry,
+  Registry,
+  Config,
+  setDefaultLanguage,
+  Orm,
+  PERSON_PROP_IDS,
+  serializePersonSlim,
+  serializePersonExtended,
+  serializePersonProv,
+  Person,
+  NewPersonWithId,
+  TAG_PROP_IDS,
+  serializeTagSlim,
+  serializeTagExtended,
+  serializeTagProv,
+  Tag,
+  NewTagWithId,
+  BOOK_PROP_IDS,
+  serializeBookSlim,
+  serializeBookExtended,
+  serializeBookProv,
+  Book,
+  BookInstance,
+  NewBookWithId,
+  ModelTypes
+};
+//# sourceMappingURL=chunk-JDUYLUDJ.js.map