@teincfood/core 0.7.9 → 0.8.0

package/dist/utils/order-transitions.js

@@ -0,0 +1,185 @@
+export const ORDER_STATUSES = [
+    "pending",
+    "awaiting_payment",
+    "accepted",
+    "preparing",
+    "ready",
+    "waiting_pickup",
+    "on_the_way",
+    "arrived",
+    "delivered",
+    "cancelled",
+];
+// 5 includes ready (buyer no-show). Locked per ans 1.
+export const CANCELLABLE_STATUSES = [
+    "pending",
+    "awaiting_payment",
+    "accepted",
+    "preparing",
+    "ready",
+];
+export const PIPELINE = ["pending", "accepted", "preparing", "ready", "delivered"];
+// ── Helpers ───────────────────────────────────────────────────────────────
+export function isUnpaid(order) {
+    const o = order;
+    return !o.is_paid && !o.paid_at && !o.payment?.is_paid;
+}
+export function isCancellable(status) {
+    return CANCELLABLE_STATUSES.includes(status);
+}
+export function cancelLabelFor(status) {
+    if (status === "pending")
+        return "Reject";
+    return "Cancel";
+}
+export function getCancelAction(status) {
+    return status === "pending" ? "reject" : "cancel";
+}
+export function isQueuedResult(result) {
+    const r = result;
+    if (!r)
+        return false;
+    return r.status === "pending" && !!r.command_id && !r.id;
+}
+export function isDeliveryOrder(order) {
+    const o = order;
+    if (o.order_type === "delivery")
+        return true;
+    return !!o.delivery_id;
+}
+export function isWalkInPickup(order) {
+    return !isDeliveryOrder(order);
+}
+// ── State machine ───────────────────────────────────────────────────────
+const STATUS_TO_ACTION = {
+    pending: "accept",
+    accepted: "start_preparing",
+    preparing: "mark_ready",
+};
+export function nextActionFor(order) {
+    const status = order.status ?? "";
+    // awaiting_payment must pay first — no pipeline progression
+    if (status === "awaiting_payment")
+        return null;
+    if (status === "pending") {
+        const isPos = !!order.is_pos;
+        if (isPos)
+            return { label: "Start preparing", key: "start_preparing" };
+        return { label: "Accept", key: "accept" };
+    }
+    if (status === "accepted")
+        return { label: "Start preparing", key: "start_preparing" };
+    if (status === "preparing")
+        return { label: "Mark ready", key: "mark_ready" };
+    if (status === "ready") {
+        const orderType = order.order_type ?? null;
+        // dine_in walk-in → Complete, else Pickup (takeout or delivery handover gate handled via getAllowedActions)
+        const label = orderType === "dine_in" ? "Complete" : "Picked up";
+        return { label, key: "complete_pickup" };
+    }
+    return null;
+}
+export function canTransition(order, action) {
+    const status = order.status ?? "";
+    if (status === "cancelled" || status === "delivered")
+        return false;
+    // awaiting_payment: only pay/confirm_cash/cancel/reject
+    if (status === "awaiting_payment") {
+        return action === "pay" || action === "confirm_cash" || action === "cancel" || action === "reject";
+    }
+    switch (action) {
+        case "accept":
+            return status === "pending" && !order.is_pos;
+        case "reject":
+            return status === "pending";
+        case "start_preparing":
+            return status === "accepted" || (status === "pending" && !!order.is_pos);
+        case "mark_ready":
+            return status === "preparing";
+        case "complete_pickup":
+            // walk-in only — delivery uses handover gates
+            return status === "ready" && isWalkInPickup(order);
+        case "cancel":
+            return isCancellable(status);
+        case "assign_rider":
+            return status === "ready" && isDeliveryOrder(order) && !order.delivery_id;
+        case "confirm_handover":
+            return (status === "ready" || status === "waiting_pickup") && isDeliveryOrder(order) && !!order.delivery_id;
+        case "confirm_cash":
+        case "pay":
+            return isUnpaid(order) && status !== "cancelled" && status !== "delivered";
+        default:
+            return false;
+    }
+}
+export function getAllowedActions(order) {
+    const status = order.status ?? "";
+    if (status === "cancelled" || status === "delivered" || status === "arrived")
+        return [];
+    if (status === "awaiting_payment") {
+        const actions = ["pay", "confirm_cash"];
+        if (isCancellable(status))
+            actions.push("cancel");
+        return actions;
+    }
+    if (status === "pending") {
+        const isPos = !!order.is_pos;
+        const actions = isPos ? [] : ["accept", "reject"];
+        if (isPos)
+            actions.push("start_preparing");
+        if (isCancellable(status)) {
+            // reject already covers pending; cancel alias not needed
+        }
+        // Pending can also start preparing directly on some flows — expose via canTransition but primary is accept/reject
+        return actions;
+    }
+    if (status === "accepted") {
+        const actions = ["start_preparing"];
+        if (isCancellable(status))
+            actions.push("cancel");
+        return actions;
+    }
+    if (status === "preparing") {
+        const actions = ["mark_ready"];
+        if (isCancellable(status))
+            actions.push("cancel");
+        return actions;
+    }
+    if (status === "ready") {
+        if (isDeliveryOrder(order)) {
+            const hasDelivery = !!order.delivery_id;
+            if (!hasDelivery)
+                return ["assign_rider", ...(isCancellable(status) ? ["cancel"] : [])];
+            return ["confirm_handover", ...(isCancellable(status) ? ["cancel"] : [])];
+        }
+        // walk-in
+        const actions = ["complete_pickup"];
+        if (isCancellable(status))
+            actions.push("cancel");
+        if (isUnpaid(order)) {
+            // cash collect also allowed on ready walk-in
+            actions.push("confirm_cash");
+        }
+        return actions;
+    }
+    if (status === "waiting_pickup" || status === "on_the_way") {
+        if (isDeliveryOrder(order))
+            return ["confirm_handover"];
+        return [];
+    }
+    return [];
+}
+// Re-export queued status map for callers that need it without importing sync internals
+export const QUEUED_STATUS_BY_COMMAND = {
+    "order:accept": "accepted",
+    "order:reject": "cancelled",
+    "order:start_preparing": "preparing",
+    "order:mark_ready": "ready",
+    "order:complete_pickup": "delivered",
+    "order:cancel": "cancelled",
+    "delivery:assign": "assigned",
+    "delivery:confirm_handover": "delivered",
+};
+export function getQueuedStatus(commandType) {
+    return QUEUED_STATUS_BY_COMMAND[commandType] ?? null;
+}

package/dist/utils/sync-logger.js

@@ -7,18 +7,19 @@
 function emit(entry) {
     const { level, namespace, message, data } = entry;
     const tag = `[${namespace}] ${message}`;
+    const hasData = data !== undefined && data !== null && Object.keys(data).length > 0;
     switch (level) {
         case "debug":
-            console.debug(tag, data);
+            hasData ? console.debug(tag, data) : console.debug(tag);
             break;
         case "info":
-            console.info(tag, data);
+            hasData ? console.info(tag, data) : console.info(tag);
             break;
         case "warn":
-            console.warn(tag, data);
+            hasData ? console.warn(tag, data) : console.warn(tag);
             break;
         case "error":
-            console.error(tag, data);
+            hasData ? console.error(tag, data) : console.error(tag);
             break;
     }
 }

package/dist/validation/offline.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Offline validation mirror — frontend accepts exactly what the backend
+ * accepts, so a locally-committed write is never rejected on sync for a
+ * reason we could have caught. Each rule cites its backend changeset.
+ *
+ * Throws ValidationError (with `details` map for per-field form errors) —
+ * never returns. Call before every local commit.
+ */
+export declare class ValidationError extends Error {
+    details: Record<string, string>;
+    constructor(message: string, details?: Record<string, string>);
+}
+/** Mirrors MenuItem.changeset: required name/base_price_minor/category_id, price ≥ 0, category UUID. */
+export declare function validateMenuItemInput(input: {
+    name?: unknown;
+    price_minor?: unknown;
+    priceMinor?: unknown;
+    category_id?: unknown;
+    categoryId?: unknown;
+    variants?: Array<{
+        name?: unknown;
+    }>;
+    extras?: Array<{
+        name?: unknown;
+    }>;
+}): void;
+/** Mirrors MenuCategory.changeset: required name. */
+export declare function validateMenuCategoryInput(input: {
+    name?: unknown;
+}): void;
+/** Mirrors Order.changeset: required payment_mode/total/currency, amounts ≥ 0. */
+export declare function validateOrderCreateInput(input: {
+    payment_mode?: unknown;
+    pos_payment_method?: unknown;
+    total_minor?: unknown;
+    currency_code?: unknown;
+    currency?: unknown;
+    items?: unknown;
+    order_type?: unknown;
+    delivery_address?: unknown;
+}): void;
+/** Mirrors BusinessMemberInvitation changeset: email format. */
+export declare function validateInviteInput(input: {
+    email?: unknown;
+    invited_email?: unknown;
+}): void;

package/dist/validation/offline.js

@@ -0,0 +1,79 @@
+/**
+ * Offline validation mirror — frontend accepts exactly what the backend
+ * accepts, so a locally-committed write is never rejected on sync for a
+ * reason we could have caught. Each rule cites its backend changeset.
+ *
+ * Throws ValidationError (with `details` map for per-field form errors) —
+ * never returns. Call before every local commit.
+ */
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const EMAIL_RE = /^[^\s]+@[^\s]+\.[^\s]+$/;
+export class ValidationError extends Error {
+    constructor(message, details = {}) {
+        super(message);
+        this.name = "ValidationError";
+        this.details = details;
+    }
+}
+function fail(field, message, details) {
+    details[field] = message;
+    throw new ValidationError(message, details);
+}
+/** Mirrors MenuItem.changeset: required name/base_price_minor/category_id, price ≥ 0, category UUID. */
+export function validateMenuItemInput(input) {
+    const details = {};
+    const name = input.name;
+    if (typeof name !== "string" || !name.trim())
+        fail("name", "Name is required", details);
+    const minor = input.price_minor ?? input.priceMinor;
+    if (typeof minor !== "number" || !Number.isFinite(minor))
+        fail("price_minor", "Price is required", details);
+    if (minor < 0)
+        fail("price_minor", "Price must be 0 or more", details);
+    const categoryId = input.category_id ?? input.categoryId;
+    if (typeof categoryId !== "string" || !categoryId)
+        fail("category_id", "Category is required", details);
+    if (!UUID_RE.test(categoryId)) {
+        // Backend enforces UUID format on category_id — client UUIDs from the
+        // envelope builder always pass; temp form ids must never reach here.
+        fail("category_id", "Category must be a valid UUID", details);
+    }
+    for (const v of input.variants ?? []) {
+        if (!v || typeof v.name !== "string" || !v.name.trim())
+            fail("variants", "Variant name is required", details);
+    }
+    for (const e of input.extras ?? []) {
+        if (!e || typeof e.name !== "string" || !e.name.trim())
+            fail("extras", "Extra name is required", details);
+    }
+}
+/** Mirrors MenuCategory.changeset: required name. */
+export function validateMenuCategoryInput(input) {
+    const details = {};
+    if (typeof input.name !== "string" || !input.name.trim())
+        fail("name", "Name is required", details);
+}
+/** Mirrors Order.changeset: required payment_mode/total/currency, amounts ≥ 0. */
+export function validateOrderCreateInput(input) {
+    const details = {};
+    const items = input.item_snapshots ?? input.items;
+    if (!Array.isArray(items) || items.length === 0)
+        fail("items", "Order must have at least one item", details);
+    for (const k of ["total_minor", "subtotal_minor", "delivery_fee_minor", "tax_minor"]) {
+        const v = input[k];
+        if (v !== undefined && (typeof v !== "number" || v < 0))
+            fail(k, `${k} must be 0 or more`, details);
+    }
+    if (input.order_type === "delivery" && !input.delivery_address) {
+        fail("delivery_address", "Delivery address is required for delivery orders", details);
+    }
+}
+/** Mirrors BusinessMemberInvitation changeset: email format. */
+export function validateInviteInput(input) {
+    const details = {};
+    const email = input.invited_email ?? input.email;
+    if (typeof email !== "string" || !email.trim())
+        fail("email", "Email is required", details);
+    if (!EMAIL_RE.test(email))
+        fail("email", "Invalid email format", details);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teincfood/core",
-  "version": "0.7.9",
+  "version": "0.8.0",
   "description": "TeincFood shared offline-first core — types, sync engine, local DB, reference data, and repositories for mobile + desktop",
   "type": "module",
   "main": "dist/index.js",
@@ -53,12 +53,17 @@
     "@tanstack/react-query": "^5.102.2",
     "@types/node": "^26.2.0",
     "@types/react": "^19.2.18",
+    "bonjour-service": "^1.4.4",
     "react": "^19.2.8",
+    "tsx": "^4.23.13",
     "typescript": "^7.0.2",
     "vitest": "^3.1.0"
   },
   "license": "MIT",
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "@tanstack/query-async-storage-persister": "^5.102.8"
   }
 }

package/dist/pricing/engine.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/pricing/engine.test.js

@@ -1,142 +0,0 @@
-/**
- * Server-parity tests for the pricing engine.
- *
- * Mirrors the backend ExUnit vectors in
- * pos_controller_test.exs (inclusive / exclusive / mixed) and the
- * rounding formulas in Orders.calculate_tax_amount. Golden values below come
- * directly from the Elixir implementation so the two runtimes never diverge.
- */
-import { describe, it, expect } from "vitest";
-import { calculatePricing, calculateTaxLines, calculateExclusiveTax, calculateInclusiveTaxShare, } from "./engine";
-function cart(unitPriceMinor, quantity = 1, addonsMinor = []) {
-    return [
-        {
-            id: "cart-1",
-            menu_item: {
-                id: "item-1",
-                name: "Test Item",
-                description: null,
-                basePrice: { amountMinor: unitPriceMinor, currencyCode: "GHS" },
-                image_url: null,
-                is_available: true,
-                dietary_tags: [],
-                category_id: "cat-1",
-                business_id: "biz-1",
-                category: null,
-                variants: [],
-                extras: [],
-                inserted_at: "",
-                updated_at: "",
-            },
-            quantity,
-            selected_variant: null,
-            selected_addons: addonsMinor.map((price_minor, i) => ({
-                addon_id: `addon-${i}`,
-                name: `Addon ${i}`,
-                price_minor,
-            })),
-            notes: "",
-            // unit_price_minor already includes variant + addons (matches pos.store)
-            unit_price_minor: unitPriceMinor,
-        },
-    ];
-}
-function taxRule(overrides) {
-    return {
-        id: "tax-1",
-        business_id: "biz-1",
-        country_code: "GH",
-        applies_to: "subtotal",
-        is_inclusive: false,
-        is_active: true,
-        display_order: 0,
-        inserted_at: "",
-        updated_at: "",
-        ...overrides,
-    };
-}
-describe("calculateExclusiveTax / calculateInclusiveTaxShare (backend rounding)", () => {
-    it("computes exclusive tax = floor(amount*rate/10000)", () => {
-        expect(calculateExclusiveTax(2400, 1000)).toBe(240); // 10%
-        expect(calculateExclusiveTax(1200, 1000)).toBe(120);
-        expect(calculateExclusiveTax(2400, 0)).toBe(0);
-        expect(calculateExclusiveTax(0, 1000)).toBe(0);
-    });
-    it("computes inclusive share = floor(amount*rate/(10000+rate))", () => {
-        // Backend: div(2400 * 7500 + 5000, 107500) = 1028
-        expect(calculateInclusiveTaxShare(2400, 7500)).toBe(1028);
-        expect(calculateInclusiveTaxShare(0, 7500)).toBe(0);
-        expect(calculateInclusiveTaxShare(2400, 0)).toBe(0);
-    });
-});
-describe("calculateTaxLines", () => {
-    it("returns exclusive-only additions for exclusive rules", () => {
-        const rules = [taxRule({ name: "Service", code: "service", rate_basis_points: 1000 })];
-        const { tax_lines, tax_minor, exclusive_tax_minor } = calculateTaxLines(2400, rules);
-        expect(tax_minor).toBe(240);
-        expect(exclusive_tax_minor).toBe(240);
-        expect(tax_lines[0].is_inclusive).toBe(false);
-        expect(tax_lines[0].tax_amount_minor).toBe(240);
-    });
-    it("returns embedded amounts for inclusive rules (not added to total)", () => {
-        const rules = [taxRule({ name: "Incl VAT", code: "incl_vat", rate_basis_points: 7500, is_inclusive: true })];
-        const { tax_lines, tax_minor, exclusive_tax_minor } = calculateTaxLines(2400, rules);
-        expect(tax_minor).toBe(1028); // display share
-        expect(exclusive_tax_minor).toBe(0); // nothing added to total
-        expect(tax_lines[0].is_inclusive).toBe(true);
-        expect(tax_lines[0].tax_amount_minor).toBe(1028);
-    });
-    it("applies tax to discounted subtotal first", () => {
-        const rules = [taxRule({ name: "Service", code: "service", rate_basis_points: 1000 })];
-        const { exclusive_tax_minor } = calculateTaxLines(2400, rules, 400, 0); // 2000 taxable
-        expect(exclusive_tax_minor).toBe(200);
-    });
-    it("honors applies_to = subtotal_plus_delivery", () => {
-        const rules = [
-            taxRule({ name: "Service", code: "service", rate_basis_points: 1000, applies_to: "subtotal_plus_delivery" }),
-        ];
-        const { exclusive_tax_minor } = calculateTaxLines(2400, rules, 0, 600); // 3000 taxable
-        expect(exclusive_tax_minor).toBe(300);
-    });
-});
-describe("calculatePricing (POS parity with backend)", () => {
-    it("no tax → total == subtotal", () => {
-        const pricing = calculatePricing({ items: cart(1200, 2), taxRules: [], currency_code: "GHS" });
-        expect(pricing.subtotal_minor).toBe(2400);
-        expect(pricing.total_minor).toBe(2400);
-        expect(pricing.exclusive_tax_minor).toBe(0);
-    });
-    it("inclusive-only tax does NOT inflate total (backend vector: 2400 → 2400)", () => {
-        const rules = [taxRule({ name: "Incl VAT", code: "incl_vat", rate_basis_points: 7500, is_inclusive: true })];
-        const pricing = calculatePricing({ items: cart(1200, 2), taxRules: rules, currency_code: "GHS" });
-        expect(pricing.subtotal_minor).toBe(2400);
-        expect(pricing.total_minor).toBe(2400); // NOT 2400 + 168
-        expect(pricing.exclusive_tax_minor).toBe(0);
-        expect(pricing.tax_minor).toBe(1028);
-        expect(pricing.tax_lines).toHaveLength(1);
-        expect(pricing.tax_lines[0].is_inclusive).toBe(true);
-    });
-    it("exclusive tax is added on top (backend vector: 2400 → 2640)", () => {
-        const rules = [taxRule({ name: "Service", code: "service", rate_basis_points: 1000 })];
-        const pricing = calculatePricing({ items: cart(1200, 2), taxRules: rules, currency_code: "GHS" });
-        expect(pricing.subtotal_minor).toBe(2400);
-        expect(pricing.exclusive_tax_minor).toBe(240);
-        expect(pricing.total_minor).toBe(2640);
-    });
-    it("mixed inclusive + exclusive adds only the exclusive portion (backend vector: 2640)", () => {
-        const rules = [
-            taxRule({ name: "Incl VAT", code: "incl_vat", rate_basis_points: 7500, is_inclusive: true }),
-            taxRule({ name: "Service", code: "service", rate_basis_points: 1000 }),
-        ];
-        const pricing = calculatePricing({ items: cart(1200, 2), taxRules: rules, currency_code: "GHS" });
-        expect(pricing.total_minor).toBe(2640);
-        expect(pricing.exclusive_tax_minor).toBe(240);
-        expect(pricing.tax_minor).toBe(1028 + 240); // display breakdown
-        expect(pricing.tax_lines).toHaveLength(2);
-    });
-    it("applies tips when provided (POS total = subtotal + excl tax + tip)", () => {
-        const rules = [taxRule({ name: "Service", code: "service", rate_basis_points: 1000 })];
-        const pricing = calculatePricing({ items: cart(1200, 2), taxRules: rules, tip_minor: 500, currency_code: "GHS" });
-        expect(pricing.total_minor).toBe(2400 + 240 + 500);
-    });
-});

package/dist/reference/lww.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/reference/lww.test.js

@@ -1,23 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { lwwMerge, toLWWMap, fromLWWMap } from "./lww";
-describe("LWW merge", () => {
-    it("divergent fields both merge", () => {
-        const a = toLWWMap({ price: 500 }, "1000-000000-01", "01");
-        const b = toLWWMap({ name: "Spicy" }, "1001-000000-02", "02");
-        const merged = lwwMerge(lwwMerge(null, a), b);
-        expect(fromLWWMap(merged)).toEqual({ price: 500, name: "Spicy" });
-    });
-    it("same field last HLC wins", () => {
-        const a = toLWWMap({ price: 500 }, "1000-000000-01", "01");
-        const b = toLWWMap({ price: 600 }, "1001-000000-02", "02");
-        const merged = lwwMerge(a, b);
-        expect(merged.price.value).toBe(600);
-        const merged2 = lwwMerge(b, a);
-        expect(merged2.price.value).toBe(600);
-    });
-    it("idempotent", () => {
-        const a = toLWWMap({ x: 1 }, "1000-000000-01", "01");
-        const m1 = lwwMerge(a, a);
-        expect(m1).toEqual(a);
-    });
-});

package/dist/reference/operations.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/reference/operations.test.js

@@ -1,66 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { getReferenceData, setReferenceData, mergeReferenceData } from "./operations";
-// simple in-memory sqlite mock for operations tests
-class MemDB {
-    constructor() {
-        this.tables = new Map();
-    }
-    async execAsync(_sql) { }
-    async runAsync(sql, ...params) {
-        if (sql.includes("INSERT INTO reference_data")) {
-            const [business_id, key, version, payload, downloaded_at, last_event_id, last_hlc] = params;
-            let m = this.tables.get("reference_data");
-            if (!m) {
-                m = new Map();
-                this.tables.set("reference_data", m);
-            }
-            const existing = m.get(`${business_id}:${key}`);
-            // mimic merge behavior via setReferenceData logic in test calling mergeReferenceData
-            m.set(`${business_id}:${key}`, JSON.stringify({ business_id, key, version, payload, downloaded_at, last_event_id, last_hlc }));
-            return { lastInsertRowId: 1, changes: 1 };
-        }
-        if (sql.includes("INSERT INTO reference_data") && sql.includes("ON CONFLICT")) { }
-        return { lastInsertRowId: 1, changes: 1 };
-    }
-    async getFirstAsync(sql, ...params) {
-        if (sql.includes("SELECT * FROM reference_data")) {
-            const [business_id, key] = params;
-            const m = this.tables.get("reference_data");
-            if (!m)
-                return null;
-            const raw = m.get(`${business_id}:${key}`);
-            if (!raw)
-                return null;
-            const j = JSON.parse(raw);
-            return { key: j.key, version: j.version, payload: j.payload, downloaded_at: j.downloaded_at, last_event_id: j.last_event_id, last_hlc: j.last_hlc };
-        }
-        if (sql.includes("SELECT version")) {
-            const [business_id, key] = params;
-            const m = this.tables.get("reference_data");
-            const raw = m?.get(`${business_id}:${key}`);
-            if (!raw)
-                return null;
-            const j = JSON.parse(raw);
-            return { version: j.version };
-        }
-        return null;
-    }
-    async getAllAsync() { return []; }
-}
-describe("reference operations LWW", () => {
-    it("merge keeps newer HLC", async () => {
-        const db = new MemDB();
-        await setReferenceData(db, "biz1", { key: "business:profile", version: "1000-000000-01", payload: { name: "A" }, downloadedAt: new Date().toISOString(), lastHlc: "1000-000000-01", lastEventId: "evt_1" });
-        let rec = await getReferenceData(db, "biz1", "business:profile");
-        expect(rec?.lastHlc).toBe("1000-000000-01");
-        // older HLC should not overwrite
-        await mergeReferenceData(db, "biz1", "business:profile", { name: "B" }, "0999-000000-01", "evt_0");
-        rec = await getReferenceData(db, "biz1", "business:profile");
-        // still A because incoming older
-        expect(rec?.payload).toEqual({ name: "A" });
-        // newer wins
-        await mergeReferenceData(db, "biz1", "business:profile", { name: "C" }, "1001-000000-02", "evt_2");
-        rec = await getReferenceData(db, "biz1", "business:profile");
-        expect(rec?.payload).toEqual({ name: "C" });
-    });
-});

package/dist/standalone.integration.test.d.ts

@@ -1 +0,0 @@
-export {};