@jgengine/core 0.10.0 → 0.12.0

package/dist/economy/auctionBook.js

@@ -0,0 +1,213 @@
+/**
+ * Timed-bid auctions in the WoW/BDO auction-house mold: post an item with a start price, minimum
+ * increment, and optional buyout; bids escrow currency, outbid players are refunded into their
+ * collection box, bids near the close extend it (anti-snipe), and settlement pays the seller minus
+ * the house cut while the item lands in the winner's collection box. Unsold auctions return the
+ * goods to the seller's box. Wallet and inventory movement is the caller's job (mirrors
+ * `economy/listingBook`) — this primitive owns the auction lifecycle and the escrowed
+ * collection-box bookkeeping behind it.
+ *
+ * @capability auction-book timed bid auctions with escrowed bids, buyout, anti-snipe close extension, and collection-box settlement
+ */
+export function createAuctionBook(config) {
+    const auctions = new Map();
+    const boxes = new Map();
+    let counter = 0;
+    function boxOf(playerId) {
+        let box = boxes.get(playerId);
+        if (box === undefined) {
+            box = { currency: {}, items: [] };
+            boxes.set(playerId, box);
+        }
+        return box;
+    }
+    function creditCurrency(playerId, currency, amount) {
+        const box = boxOf(playerId);
+        box.currency[currency] = (box.currency[currency] ?? 0) + amount;
+    }
+    function creditItem(playerId, itemId, count) {
+        const box = boxOf(playerId);
+        const existing = box.items.find((stack) => stack.itemId === itemId);
+        if (existing !== undefined)
+            existing.count += count;
+        else
+            box.items.push({ itemId, count });
+    }
+    function countOf(sellerId) {
+        let total = 0;
+        for (const auction of auctions.values())
+            if (auction.sellerId === sellerId)
+                total += 1;
+        return total;
+    }
+    function snapshot(state) {
+        return { ...state, highBid: state.highBid };
+    }
+    function minimumBid(state) {
+        return state.highBid === null ? state.startPrice : state.highBid.amount + state.minIncrement;
+    }
+    function settle(state, winnerId, price) {
+        auctions.delete(state.id);
+        const houseCut = Math.floor(price * config.cutRate);
+        const sellerProceeds = price - houseCut;
+        creditCurrency(state.sellerId, state.currency, sellerProceeds);
+        creditItem(winnerId, state.itemId, state.count);
+        return { status: "sold", auction: snapshot(state), winnerId, price, houseCut, sellerProceeds };
+    }
+    function acceptBid(state, bidderId, amount, now) {
+        if (state.highBid !== null) {
+            creditCurrency(state.highBid.bidderId, state.currency, state.highBid.amount);
+        }
+        if (state.buyoutPrice !== null && amount >= state.buyoutPrice) {
+            state.highBid = { bidderId, amount: state.buyoutPrice, at: now };
+            const settlement = settle(state, bidderId, state.buyoutPrice);
+            if (settlement.status !== "sold")
+                throw new Error("unreachable");
+            return { status: "ok", auction: settlement.auction, escrowed: state.buyoutPrice, won: true };
+        }
+        state.highBid = { bidderId, amount, at: now };
+        const window = config.antiSnipeWindowSeconds ?? 0;
+        const extension = config.antiSnipeExtensionSeconds ?? 0;
+        if (window > 0 && extension > 0 && state.endsAt - now < window) {
+            state.endsAt = Math.max(state.endsAt, now + extension);
+        }
+        return { status: "ok", auction: snapshot(state), escrowed: amount, won: false };
+    }
+    return {
+        post(input) {
+            if (!Number.isInteger(input.count) || input.count < 1) {
+                return { status: "rejected", reason: "invalid-count" };
+            }
+            if (!Number.isFinite(input.startPrice) || input.startPrice <= 0) {
+                return { status: "rejected", reason: "invalid-price" };
+            }
+            if (!Number.isFinite(input.minIncrement) || input.minIncrement <= 0) {
+                return { status: "rejected", reason: "invalid-increment" };
+            }
+            if (input.buyoutPrice !== undefined) {
+                if (!Number.isFinite(input.buyoutPrice) || input.buyoutPrice < input.startPrice) {
+                    return { status: "rejected", reason: "invalid-buyout" };
+                }
+            }
+            if (countOf(input.sellerId) >= config.maxAuctionsPerSeller) {
+                return { status: "rejected", reason: "auction-cap-reached" };
+            }
+            const id = input.id ?? `auction_${(counter += 1)}`;
+            const state = {
+                id,
+                sellerId: input.sellerId,
+                itemId: input.itemId,
+                count: input.count,
+                currency: input.currency,
+                startPrice: input.startPrice,
+                minIncrement: input.minIncrement,
+                buyoutPrice: input.buyoutPrice ?? null,
+                listedAt: input.now,
+                endsAt: input.now + config.durationSeconds,
+                highBid: null,
+            };
+            auctions.set(id, state);
+            return { status: "ok", auction: snapshot(state) };
+        },
+        bid(auctionId, bidderId, amount, now) {
+            const state = auctions.get(auctionId);
+            if (state === undefined)
+                return { status: "rejected", reason: "not-found" };
+            if (state.endsAt <= now)
+                return { status: "rejected", reason: "ended" };
+            if (state.sellerId === bidderId)
+                return { status: "rejected", reason: "own-auction" };
+            if (!Number.isFinite(amount) || amount <= 0) {
+                return { status: "rejected", reason: "invalid-amount" };
+            }
+            if (state.highBid?.bidderId === bidderId) {
+                return { status: "rejected", reason: "already-leading" };
+            }
+            if (amount < minimumBid(state))
+                return { status: "rejected", reason: "bid-too-low" };
+            return acceptBid(state, bidderId, amount, now);
+        },
+        buyout(auctionId, buyerId, now) {
+            const state = auctions.get(auctionId);
+            if (state === undefined)
+                return { status: "rejected", reason: "not-found" };
+            if (state.endsAt <= now)
+                return { status: "rejected", reason: "ended" };
+            if (state.sellerId === buyerId)
+                return { status: "rejected", reason: "own-auction" };
+            if (state.buyoutPrice === null)
+                return { status: "rejected", reason: "no-buyout" };
+            if (state.highBid?.bidderId === buyerId) {
+                creditCurrency(buyerId, state.currency, state.highBid.amount);
+                state.highBid = null;
+            }
+            return acceptBid(state, buyerId, state.buyoutPrice, now);
+        },
+        cancel(auctionId, sellerId) {
+            const state = auctions.get(auctionId);
+            if (state === undefined)
+                return { status: "rejected", reason: "not-found" };
+            if (state.sellerId !== sellerId)
+                return { status: "rejected", reason: "not-owner" };
+            if (state.highBid !== null)
+                return { status: "rejected", reason: "has-bids" };
+            auctions.delete(auctionId);
+            return { status: "ok", auction: snapshot(state) };
+        },
+        settleExpired(now) {
+            const ended = [];
+            for (const state of auctions.values())
+                if (state.endsAt <= now)
+                    ended.push(state);
+            const settlements = [];
+            for (const state of ended) {
+                if (state.highBid === null) {
+                    auctions.delete(state.id);
+                    creditItem(state.sellerId, state.itemId, state.count);
+                    settlements.push({ status: "returned", auction: snapshot(state) });
+                }
+                else {
+                    settlements.push(settle(state, state.highBid.bidderId, state.highBid.amount));
+                }
+            }
+            return settlements;
+        },
+        get(auctionId) {
+            const state = auctions.get(auctionId);
+            return state === undefined ? null : snapshot(state);
+        },
+        active() {
+            return [...auctions.values()].map(snapshot);
+        },
+        auctionsOf(sellerId) {
+            return [...auctions.values()].filter((a) => a.sellerId === sellerId).map(snapshot);
+        },
+        countOf,
+        collectionOf(playerId) {
+            const box = boxes.get(playerId);
+            if (box === undefined)
+                return { currency: {}, items: [] };
+            return { currency: { ...box.currency }, items: box.items.map((stack) => ({ ...stack })) };
+        },
+        claimCurrency(playerId) {
+            const box = boxOf(playerId);
+            const claimed = box.currency;
+            box.currency = {};
+            return claimed;
+        },
+        claimItem(playerId, itemId, count) {
+            const box = boxOf(playerId);
+            const index = box.items.findIndex((stack) => stack.itemId === itemId);
+            if (index === -1)
+                return false;
+            const stack = box.items[index];
+            if (stack.count < count)
+                return false;
+            if (stack.count === count)
+                box.items.splice(index, 1);
+            else
+                box.items[index] = { ...stack, count: stack.count - count };
+            return true;
+        },
+    };
+}

package/dist/economy/currency.d.ts

@@ -15,11 +15,22 @@ export type CurrencyAdjustment = {
     success: false;
     reason: string;
 };
+/** @internal */
 export declare function sanitizeCurrencyAmount(amount: number): number;
+/**
+ * Format a currency amount with its symbol and grouping for HUD display.
+ *
+ * @capability currency-format format a currency amount with its symbol for display
+  * @internal
+  */
 export declare function formatCurrencyAmount(currency: CurrencyDefinition, amount: number): string;
+/** @internal */
 export declare function insufficientCurrencyReason(currency: CurrencyDefinition, needed: number, current: number): string;
+/** @internal */
 export declare function applyCurrencyOperation(currency: CurrencyDefinition, current: number, operation: CurrencyOperation, amount: number): CurrencyAdjustment;
-/** Deducts clamp to the available balance (a delta can never overdraw); adds apply in full. */
+/** Deducts clamp to the available balance (a delta can never overdraw); adds apply in full.
+ * @internal
+ */
 export declare function resolveCurrencyDelta(current: number, delta: number): {
     operation: CurrencyOperation;
     amount: number;

package/dist/economy/currency.js

@@ -1,14 +1,23 @@
+/** @internal */
 export function sanitizeCurrencyAmount(amount) {
     return Math.max(0, Math.floor(amount));
 }
+/**
+ * Format a currency amount with its symbol and grouping for HUD display.
+ *
+ * @capability currency-format format a currency amount with its symbol for display
+  * @internal
+  */
 export function formatCurrencyAmount(currency, amount) {
     const prefix = currency.symbol ?? "";
     const suffix = currency.unit ? ` ${currency.unit}` : "";
     return `${prefix}${amount}${suffix}`;
 }
+/** @internal */
 export function insufficientCurrencyReason(currency, needed, current) {
     return `Insufficient ${currency.id}: need ${formatCurrencyAmount(currency, needed)}, have ${formatCurrencyAmount(currency, current)}`;
 }
+/** @internal */
 export function applyCurrencyOperation(currency, current, operation, amount) {
     const safeAmount = sanitizeCurrencyAmount(amount);
     if (safeAmount === 0)
@@ -19,7 +28,9 @@ export function applyCurrencyOperation(currency, current, operation, amount) {
     const appliedDelta = operation === "add" ? safeAmount : -safeAmount;
     return { success: true, newBalance: current + appliedDelta, appliedDelta };
 }
-/** Deducts clamp to the available balance (a delta can never overdraw); adds apply in full. */
+/** Deducts clamp to the available balance (a delta can never overdraw); adds apply in full.
+ * @internal
+ */
 export function resolveCurrencyDelta(current, delta) {
     const safeDelta = Math.floor(delta);
     if (safeDelta > 0)

package/dist/economy/listingBook.d.ts

@@ -0,0 +1,91 @@
+import type { ItemStack } from "../inventory/storageTier.js";
+/** One active post in a {@link ListingBook}: an item stack a seller offered at a fixed price until it expires. */
+export interface Listing {
+    readonly id: string;
+    readonly sellerId: string;
+    readonly itemId: string;
+    readonly count: number;
+    readonly price: number;
+    readonly currency: string;
+    readonly listedAt: number;
+    readonly expiresAt: number;
+}
+/** Tunables for {@link createListingBook} — per-seller listing cap, expiry window, house cut, and optional price bounds. */
+export interface ListingBookConfig {
+    maxListingsPerSeller: number;
+    expirySeconds: number;
+    cutRate: number;
+    minPrice?: number;
+    maxPrice?: number;
+}
+/** Input to {@link ListingBook.post} — the goods, asking price, and current game-time to stamp the listing with. */
+export interface PostListingInput {
+    id?: string;
+    sellerId: string;
+    itemId: string;
+    count: number;
+    price: number;
+    currency: string;
+    now: number;
+}
+/** Why {@link ListingBook.post} refused a listing. */
+export type PostListingReason = "invalid-count" | "invalid-price" | "price-too-low" | "price-too-high" | "listing-cap-reached";
+/** Result of {@link ListingBook.post}. */
+export type PostListingResult = {
+    status: "ok";
+    listing: Listing;
+} | {
+    status: "rejected";
+    reason: PostListingReason;
+};
+/** Result of {@link ListingBook.cancel}. */
+export type CancelListingResult = {
+    status: "ok";
+    listing: Listing;
+} | {
+    status: "rejected";
+    reason: "not-found" | "not-owner";
+};
+/** The financial split of a completed sale: total price, the house's cut, and what the seller's collection box was credited. */
+export interface BuyListingOutcome {
+    listing: Listing;
+    houseCut: number;
+    sellerProceeds: number;
+}
+/** Result of {@link ListingBook.buy}. */
+export type BuyListingResult = {
+    status: "ok";
+    outcome: BuyListingOutcome;
+} | {
+    status: "rejected";
+    reason: "not-found" | "expired" | "own-listing";
+};
+/** A read-only view of a seller's collection box — currency and item stacks waiting to be claimed. */
+export interface CollectionBoxSnapshot {
+    currency: Readonly<Record<string, number>>;
+    items: readonly ItemStack[];
+}
+/** A player-driven marketplace of {@link Listing}s plus the per-seller collection boxes behind it. See {@link createListingBook}. */
+export interface ListingBook {
+    post(input: PostListingInput): PostListingResult;
+    cancel(listingId: string, sellerId: string): CancelListingResult;
+    buy(listingId: string, buyerId: string, now: number): BuyListingResult;
+    sweepExpired(now: number): readonly Listing[];
+    get(listingId: string): Listing | null;
+    active(): readonly Listing[];
+    listingsOf(sellerId: string): readonly Listing[];
+    countOf(sellerId: string): number;
+    collectionOf(sellerId: string): CollectionBoxSnapshot;
+    claimCurrency(sellerId: string): Readonly<Record<string, number>>;
+    claimItem(sellerId: string, itemId: string, count: number): boolean;
+}
+/**
+ * A player-driven listing marketplace: post/cancel/buy against a shared book with a house cut on
+ * every sale, an expiry sweep that pulls unsold goods out of circulation, and a per-seller
+ * collection box holding sale proceeds and returned items until claimed. Buyer/seller wallet and
+ * inventory movement is the caller's job (mirrors `game/trade`'s split) — this primitive owns only
+ * the listing lifecycle and the escrowed collection-box bookkeeping behind it.
+ *
+ * @capability listing-book player-driven marketplace listings with a house cut, expiry sweep, and seller collection box
+ */
+export declare function createListingBook(config: ListingBookConfig): ListingBook;

package/dist/economy/listingBook.js

@@ -0,0 +1,144 @@
+/**
+ * A player-driven listing marketplace: post/cancel/buy against a shared book with a house cut on
+ * every sale, an expiry sweep that pulls unsold goods out of circulation, and a per-seller
+ * collection box holding sale proceeds and returned items until claimed. Buyer/seller wallet and
+ * inventory movement is the caller's job (mirrors `game/trade`'s split) — this primitive owns only
+ * the listing lifecycle and the escrowed collection-box bookkeeping behind it.
+ *
+ * @capability listing-book player-driven marketplace listings with a house cut, expiry sweep, and seller collection box
+ */
+export function createListingBook(config) {
+    const listings = new Map();
+    const boxes = new Map();
+    let counter = 0;
+    function boxOf(sellerId) {
+        let box = boxes.get(sellerId);
+        if (box === undefined) {
+            box = { currency: {}, items: [] };
+            boxes.set(sellerId, box);
+        }
+        return box;
+    }
+    function creditCurrency(sellerId, currency, amount) {
+        const box = boxOf(sellerId);
+        box.currency[currency] = (box.currency[currency] ?? 0) + amount;
+    }
+    function creditItem(sellerId, itemId, count) {
+        const box = boxOf(sellerId);
+        const existing = box.items.find((stack) => stack.itemId === itemId);
+        if (existing !== undefined)
+            existing.count += count;
+        else
+            box.items.push({ itemId, count });
+    }
+    function countOf(sellerId) {
+        let total = 0;
+        for (const listing of listings.values())
+            if (listing.sellerId === sellerId)
+                total += 1;
+        return total;
+    }
+    return {
+        post(input) {
+            if (!Number.isInteger(input.count) || input.count < 1) {
+                return { status: "rejected", reason: "invalid-count" };
+            }
+            if (!Number.isFinite(input.price) || input.price <= 0) {
+                return { status: "rejected", reason: "invalid-price" };
+            }
+            if (config.minPrice !== undefined && input.price < config.minPrice) {
+                return { status: "rejected", reason: "price-too-low" };
+            }
+            if (config.maxPrice !== undefined && input.price > config.maxPrice) {
+                return { status: "rejected", reason: "price-too-high" };
+            }
+            if (countOf(input.sellerId) >= config.maxListingsPerSeller) {
+                return { status: "rejected", reason: "listing-cap-reached" };
+            }
+            const id = input.id ?? `listing_${(counter += 1)}`;
+            const listing = {
+                id,
+                sellerId: input.sellerId,
+                itemId: input.itemId,
+                count: input.count,
+                price: input.price,
+                currency: input.currency,
+                listedAt: input.now,
+                expiresAt: input.now + config.expirySeconds,
+            };
+            listings.set(id, listing);
+            return { status: "ok", listing };
+        },
+        cancel(listingId, sellerId) {
+            const listing = listings.get(listingId);
+            if (listing === undefined)
+                return { status: "rejected", reason: "not-found" };
+            if (listing.sellerId !== sellerId)
+                return { status: "rejected", reason: "not-owner" };
+            listings.delete(listingId);
+            return { status: "ok", listing };
+        },
+        buy(listingId, buyerId, now) {
+            const listing = listings.get(listingId);
+            if (listing === undefined)
+                return { status: "rejected", reason: "not-found" };
+            if (listing.sellerId === buyerId)
+                return { status: "rejected", reason: "own-listing" };
+            if (listing.expiresAt <= now)
+                return { status: "rejected", reason: "expired" };
+            listings.delete(listingId);
+            const houseCut = Math.floor(listing.price * config.cutRate);
+            const sellerProceeds = listing.price - houseCut;
+            creditCurrency(listing.sellerId, listing.currency, sellerProceeds);
+            return { status: "ok", outcome: { listing, houseCut, sellerProceeds } };
+        },
+        sweepExpired(now) {
+            const expired = [];
+            for (const listing of listings.values()) {
+                if (listing.expiresAt <= now)
+                    expired.push(listing);
+            }
+            for (const listing of expired) {
+                listings.delete(listing.id);
+                creditItem(listing.sellerId, listing.itemId, listing.count);
+            }
+            return expired;
+        },
+        get(listingId) {
+            return listings.get(listingId) ?? null;
+        },
+        active() {
+            return [...listings.values()];
+        },
+        listingsOf(sellerId) {
+            return [...listings.values()].filter((listing) => listing.sellerId === sellerId);
+        },
+        countOf,
+        collectionOf(sellerId) {
+            const box = boxes.get(sellerId);
+            if (box === undefined)
+                return { currency: {}, items: [] };
+            return { currency: { ...box.currency }, items: box.items.map((stack) => ({ ...stack })) };
+        },
+        claimCurrency(sellerId) {
+            const box = boxOf(sellerId);
+            const claimed = box.currency;
+            box.currency = {};
+            return claimed;
+        },
+        claimItem(sellerId, itemId, count) {
+            const box = boxOf(sellerId);
+            const index = box.items.findIndex((stack) => stack.itemId === itemId);
+            if (index === -1)
+                return false;
+            const stack = box.items[index];
+            if (stack.count < count)
+                return false;
+            if (stack.count === count)
+                box.items.splice(index, 1);
+            else
+                box.items[index] = { ...stack, count: stack.count - count };
+            return true;
+        },
+    };
+}

package/dist/economy/priceHistory.d.ts

@@ -0,0 +1,44 @@
+/** One completed sale recorded into a {@link PriceHistory}. */
+export interface SaleRecord {
+    readonly itemId: string;
+    readonly count: number;
+    readonly unitPrice: number;
+    readonly currency: string;
+    readonly at: number;
+}
+/**
+ * Tunables for {@link createPriceHistory} — the per-item sample cap bounds memory; the optional
+ * window drops samples older than `windowSeconds` whenever the history is written or read with a
+ * newer timestamp.
+ */
+export interface PriceHistoryConfig {
+    maxSamplesPerItem: number;
+    windowSeconds?: number;
+}
+/** Aggregated market stats for one item over the retained samples. */
+export interface PriceStats {
+    readonly sampleCount: number;
+    readonly volume: number;
+    readonly minUnitPrice: number;
+    readonly maxUnitPrice: number;
+    readonly averageUnitPrice: number;
+    readonly latestUnitPrice: number;
+}
+/** A bounded rolling record of completed sales per item. See {@link createPriceHistory}. */
+export interface PriceHistory {
+    record(sale: SaleRecord): void;
+    statsOf(itemId: string, now?: number): PriceStats | null;
+    samplesOf(itemId: string, now?: number): readonly SaleRecord[];
+    itemIds(): readonly string[];
+    clear(itemId?: string): void;
+}
+/**
+ * The "market price" readout behind every auction house: a bounded rolling record of completed
+ * sales per item, aggregated into min/max/volume-weighted-average/latest unit-price stats so games
+ * can show current value and recent trends. Memory is bounded by `maxSamplesPerItem` (oldest
+ * samples drop first) and optionally by a sliding time window; timestamps are injected by the
+ * caller so the history stays deterministic.
+ *
+ * @capability price-history rolling per-item sale records aggregated into market price stats
+ */
+export declare function createPriceHistory(config: PriceHistoryConfig): PriceHistory;

package/dist/economy/priceHistory.js

@@ -0,0 +1,89 @@
+/**
+ * The "market price" readout behind every auction house: a bounded rolling record of completed
+ * sales per item, aggregated into min/max/volume-weighted-average/latest unit-price stats so games
+ * can show current value and recent trends. Memory is bounded by `maxSamplesPerItem` (oldest
+ * samples drop first) and optionally by a sliding time window; timestamps are injected by the
+ * caller so the history stays deterministic.
+ *
+ * @capability price-history rolling per-item sale records aggregated into market price stats
+ */
+export function createPriceHistory(config) {
+    const samples = new Map();
+    function trim(list, now) {
+        if (config.windowSeconds !== undefined && now !== undefined) {
+            const cutoff = now - config.windowSeconds;
+            let drop = 0;
+            while (drop < list.length && list[drop].at < cutoff)
+                drop += 1;
+            if (drop > 0)
+                list.splice(0, drop);
+        }
+        if (list.length > config.maxSamplesPerItem) {
+            list.splice(0, list.length - config.maxSamplesPerItem);
+        }
+    }
+    function retained(itemId, now) {
+        const list = samples.get(itemId);
+        if (list === undefined)
+            return null;
+        trim(list, now);
+        if (list.length === 0) {
+            samples.delete(itemId);
+            return null;
+        }
+        return list;
+    }
+    return {
+        record(sale) {
+            if (!Number.isFinite(sale.unitPrice) || sale.unitPrice < 0)
+                return;
+            if (!Number.isInteger(sale.count) || sale.count < 1)
+                return;
+            let list = samples.get(sale.itemId);
+            if (list === undefined) {
+                list = [];
+                samples.set(sale.itemId, list);
+            }
+            list.push(sale);
+            trim(list, sale.at);
+        },
+        statsOf(itemId, now) {
+            const list = retained(itemId, now);
+            if (list === null)
+                return null;
+            let volume = 0;
+            let spend = 0;
+            let min = Number.POSITIVE_INFINITY;
+            let max = Number.NEGATIVE_INFINITY;
+            for (const sale of list) {
+                volume += sale.count;
+                spend += sale.unitPrice * sale.count;
+                if (sale.unitPrice < min)
+                    min = sale.unitPrice;
+                if (sale.unitPrice > max)
+                    max = sale.unitPrice;
+            }
+            return {
+                sampleCount: list.length,
+                volume,
+                minUnitPrice: min,
+                maxUnitPrice: max,
+                averageUnitPrice: spend / volume,
+                latestUnitPrice: list[list.length - 1].unitPrice,
+            };
+        },
+        samplesOf(itemId, now) {
+            const list = retained(itemId, now);
+            return list === null ? [] : [...list];
+        },
+        itemIds() {
+            return [...samples.keys()];
+        },
+        clear(itemId) {
+            if (itemId === undefined)
+                samples.clear();
+            else
+                samples.delete(itemId);
+        },
+    };
+}