@crowdedkingdoms/crowdyjs 17.14.0-dev.1 → 18.0.1-dev.1

package/dist/kit/economy.js

@@ -1,427 +0,0 @@
-import { economyCurrencyFn, economyNames, } from './blueprints/index.js';
-import { kitContainerProperties, kitInvoke, } from './shared.js';
-/**
- * Runtime helpers for the {@link economyBlueprint} conventions: wallets with
- * per-currency balances, shop purchases, escrow trades, and player market
- * listings. Every movement of currency or items is a single gated invoke —
- * balances, stock, item identity, and ownership are all verified
- * server-side, and a denial resolves with `success: false` (never an
- * exception).
- *
- * `earn` is a trusted grant: with the default blueprint authority
- * (`'server'`) it succeeds only for app admins — call it from studio/backend
- * code, or drive grants through automations instead.
- *
- * Obtained via `client.kit(appId).economy`.
- */
-export class EconomyKit {
-    constructor(appId, gameModel, options = {}, engines) {
-        this.appId = appId;
-        this.gameModel = gameModel;
-        /** Shop (admin-priced listings; atomic buys). */
-        this.shop = {
-            /**
-             * Create a shop listing (admin — the type is admin-instantiable).
-             * `maxStock` feeds the optional restock automation.
-             */
-            create: async (input) => {
-                return this.gameModel.createContainer({
-                    appId: this.appId,
-                    typeName: this.names.listingType,
-                    displayName: input.displayName,
-                    properties: [
-                        { key: 'item_id', valueType: 'string', valueJson: JSON.stringify(input.itemId) },
-                        { key: 'price', valueType: 'int', valueJson: String(input.price) },
-                        { key: 'stock', valueType: 'int', valueJson: String(input.stock ?? 0) },
-                        {
-                            key: 'max_stock',
-                            valueType: 'int',
-                            valueJson: String(input.maxStock ?? input.stock ?? 0),
-                        },
-                        ...(input.properties ?? []),
-                    ],
-                });
-            },
-            /** List shop listings with parsed state. */
-            list: async () => {
-                const containers = await this.gameModel.containers({
-                    appId: this.appId,
-                    typeName: this.names.listingType,
-                });
-                return Promise.all(containers.map(async (c) => {
-                    const props = await kitContainerProperties(this.gameModel, String(this.appId), c.containerId);
-                    return {
-                        containerId: c.containerId,
-                        displayName: c.displayName,
-                        itemId: String(props.item_id ?? ''),
-                        price: Number(props.price ?? 0),
-                        stock: Number(props.stock ?? 0),
-                        maxStock: Number(props.max_stock ?? 0),
-                    };
-                }));
-            },
-            /**
-             * Buy one unit: wallet debit + stock decrement + item grant into
-             * `toStackId` (a stack of the listed item), all in one transaction.
-             * Resolves with the wallet's remaining balance.
-             */
-            buy: async (input) => {
-                return kitInvoke(this.gameModel, {
-                    appId: String(this.appId),
-                    functionName: this.names.buyListingFn,
-                    selfContainerId: input.listingId,
-                    params: { wallet_id: input.walletId, to_stack_id: input.toStackId },
-                });
-            },
-        };
-        /** Escrow trades (player↔player item swaps, atomic on accept). */
-        this.trades = {
-            /**
-             * Create a trade offer to another player. The stacks named here are the
-             * OFFERER's: `giveStackId` is the escrowed source, `receiveStackId`
-             * receives the wanted items when the trade is accepted. The offer's
-             * container ownership (server-assigned to the caller) is what the accept
-             * guards trust — a forged offer over someone else's stacks can never be
-             * accepted.
-             */
-            offer: async (input) => {
-                return this.gameModel.createContainer({
-                    appId: this.appId,
-                    typeName: this.names.tradeType,
-                    displayName: input.displayName ??
-                        `Trade ${input.giveQty}x ${input.giveItemId} for ${input.wantQty}x ${input.wantItemId}`,
-                    ...(input.sessionId !== undefined ? { sessionId: input.sessionId } : {}),
-                    properties: [
-                        { key: 'to_user_id', valueType: 'int', valueJson: String(input.toUserId) },
-                        {
-                            key: 'give_stack_id',
-                            valueType: 'string',
-                            valueJson: JSON.stringify(input.giveStackId),
-                        },
-                        {
-                            key: 'receive_stack_id',
-                            valueType: 'string',
-                            valueJson: JSON.stringify(input.receiveStackId),
-                        },
-                        {
-                            key: 'give_item_id',
-                            valueType: 'string',
-                            valueJson: JSON.stringify(input.giveItemId),
-                        },
-                        { key: 'give_qty', valueType: 'int', valueJson: String(input.giveQty) },
-                        {
-                            key: 'want_item_id',
-                            valueType: 'string',
-                            valueJson: JSON.stringify(input.wantItemId),
-                        },
-                        { key: 'want_qty', valueType: 'int', valueJson: String(input.wantQty) },
-                    ],
-                });
-            },
-            /**
-             * Accept a trade as the invited player, supplying YOUR two stacks: the
-             * one paying the wanted items and the one receiving the given items. The
-             * offerer's stacks come from the offer record. All four quantity writes
-             * commit atomically or not at all.
-             */
-            accept: async (input) => {
-                const offer = await this.trades.get(input.offerId);
-                return kitInvoke(this.gameModel, {
-                    appId: String(this.appId),
-                    functionName: this.names.acceptTradeFn,
-                    selfContainerId: input.offerId,
-                    params: {
-                        give_stack_id: offer.giveStackId,
-                        to_give_stack_id: input.toGiveStackId,
-                        want_stack_id: input.wantStackId,
-                        to_want_stack_id: offer.receiveStackId,
-                    },
-                });
-            },
-            /** Cancel an open trade (either party may). */
-            cancel: async (offerId) => {
-                return kitInvoke(this.gameModel, {
-                    appId: String(this.appId),
-                    functionName: this.names.cancelTradeFn,
-                    selfContainerId: offerId,
-                    params: {},
-                });
-            },
-            /** Read one trade offer with parsed state. */
-            get: async (offerId) => {
-                const container = await this.gameModel.container({
-                    appId: this.appId,
-                    containerId: offerId,
-                });
-                return this.toTrade(container.containerId, container.displayName, container.ownerUserId != null ? String(container.ownerUserId) : null);
-            },
-            /** List trades the user created or was invited to (open ones first). */
-            listMine: async (userId) => {
-                const containers = await this.gameModel.containers({
-                    appId: this.appId,
-                    typeName: this.names.tradeType,
-                });
-                const all = await Promise.all(containers.map((c) => this.toTrade(c.containerId, c.displayName, c.ownerUserId != null ? String(c.ownerUserId) : null)));
-                const uid = String(userId);
-                return all
-                    .filter((t) => t.fromUserId === uid || String(t.toUserId) === uid)
-                    .sort((a, b) => Number(b.status === 'open') - Number(a.status === 'open'));
-            },
-        };
-        /** Player market (list a stack for currency; atomic purchases). */
-        this.market = {
-            /**
-             * List items for sale: names YOUR escrowed source stack and the ask
-             * price. Payment lands straight in your wallet when someone buys.
-             */
-            list: async (input) => {
-                return this.gameModel.createContainer({
-                    appId: this.appId,
-                    typeName: this.names.marketType,
-                    displayName: input.displayName ?? `${input.quantity}x ${input.itemId} for ${input.price}`,
-                    ...(input.sessionId !== undefined ? { sessionId: input.sessionId } : {}),
-                    properties: [
-                        {
-                            key: 'stack_id',
-                            valueType: 'string',
-                            valueJson: JSON.stringify(input.stackId),
-                        },
-                        {
-                            key: 'item_id',
-                            valueType: 'string',
-                            valueJson: JSON.stringify(input.itemId),
-                        },
-                        { key: 'quantity', valueType: 'int', valueJson: String(input.quantity) },
-                        { key: 'price', valueType: 'int', valueJson: String(input.price) },
-                    ],
-                });
-            },
-            /** Browse market listings (active ones only by default). */
-            browse: async (options = {}) => {
-                const containers = await this.gameModel.containers({
-                    appId: this.appId,
-                    typeName: this.names.marketType,
-                });
-                const all = await Promise.all(containers.map(async (c) => {
-                    const props = await kitContainerProperties(this.gameModel, String(this.appId), c.containerId);
-                    return {
-                        containerId: c.containerId,
-                        displayName: c.displayName,
-                        sellerUserId: c.ownerUserId != null ? String(c.ownerUserId) : null,
-                        stackId: String(props.stack_id ?? ''),
-                        itemId: String(props.item_id ?? ''),
-                        quantity: Number(props.quantity ?? 0),
-                        price: Number(props.price ?? 0),
-                        active: props.active === true,
-                    };
-                }));
-                return options.includeInactive ? all : all.filter((l) => l.active);
-            },
-            /**
-             * Buy a market listing: pays the seller's wallet and transfers the items
-             * into `toStackId` in one transaction. The seller's wallet and source
-             * stack are resolved from the listing. Resolves with the buyer wallet's
-             * remaining balance.
-             */
-            buy: async (input) => {
-                const container = await this.gameModel.container({
-                    appId: this.appId,
-                    containerId: input.listingId,
-                });
-                const props = await kitContainerProperties(this.gameModel, String(this.appId), input.listingId);
-                if (container.ownerUserId == null) {
-                    throw new Error('Market listing has no seller (unowned container)');
-                }
-                const sellerWallet = await this.ensureSellerWallet(String(container.ownerUserId));
-                return kitInvoke(this.gameModel, {
-                    appId: String(this.appId),
-                    functionName: this.names.buyMarketFn,
-                    selfContainerId: input.listingId,
-                    params: {
-                        wallet_id: input.walletId,
-                        seller_wallet_id: sellerWallet,
-                        from_stack_id: String(props.stack_id ?? ''),
-                        to_stack_id: input.toStackId,
-                    },
-                });
-            },
-            /** Take a listing down (seller only). */
-            cancel: async (listingId) => {
-                return kitInvoke(this.gameModel, {
-                    appId: String(this.appId),
-                    functionName: this.names.cancelMarketFn,
-                    selfContainerId: listingId,
-                    params: {},
-                });
-            },
-        };
-        this.typePrefix = options.typePrefix ?? '';
-        this.names = economyNames(this.typePrefix);
-        this.currencies = options.currencies ?? ['gold'];
-        this.orderBook = new MarketKit(engines, options.marketModuleName ?? 'market-engine');
-    }
-    get defaultCurrency() {
-        return this.currencies[0];
-    }
-    /**
-     * Find the player's wallet, creating it when absent (member-instantiable;
-     * the server assigns ownership to the caller). Sets the `owner_user_id`
-     * mirror property the blueprint's guards read.
-     *
-     * @param ownerUserId - The calling player's user id (decimal string).
-     */
-    async ensureWallet(ownerUserId, options = {}) {
-        const existing = await this.gameModel.containers({
-            appId: this.appId,
-            typeName: this.names.walletType,
-            ...(options.sessionId !== undefined ? { sessionId: options.sessionId } : {}),
-        });
-        const mine = existing.find((c) => c.ownerUserId != null && String(c.ownerUserId) === String(ownerUserId));
-        if (mine)
-            return mine;
-        return this.gameModel.createContainer({
-            appId: this.appId,
-            typeName: this.names.walletType,
-            displayName: options.displayName ?? `Wallet ${ownerUserId}`,
-            ...(options.sessionId !== undefined ? { sessionId: options.sessionId } : {}),
-            properties: [
-                { key: 'owner_user_id', valueType: 'int', valueJson: String(ownerUserId) },
-            ],
-        });
-    }
-    /** Read one currency balance (default: the blueprint's first currency). */
-    async balance(walletId, currency) {
-        const props = await kitContainerProperties(this.gameModel, String(this.appId), walletId);
-        return Number(props[currency ?? this.defaultCurrency] ?? 0);
-    }
-    /** Read a wallet with every configured currency balance parsed. */
-    async wallet(walletId) {
-        const container = await this.gameModel.container({
-            appId: this.appId,
-            containerId: walletId,
-        });
-        const props = await kitContainerProperties(this.gameModel, String(this.appId), walletId);
-        const balances = {};
-        for (const c of this.currencies)
-            balances[c] = Number(props[c] ?? 0);
-        return {
-            containerId: container.containerId,
-            displayName: container.displayName,
-            ownerUserId: container.ownerUserId != null ? String(container.ownerUserId) : null,
-            balances,
-        };
-    }
-    /**
-     * Mint currency into a wallet — a **trusted** grant (default blueprint
-     * authority: app admins only). Resolves with the new balance.
-     */
-    async earn(walletId, amount, currency) {
-        return kitInvoke(this.gameModel, {
-            appId: String(this.appId),
-            functionName: economyCurrencyFn('earn', currency ?? this.defaultCurrency, this.typePrefix),
-            selfContainerId: walletId,
-            params: { amount },
-        });
-    }
-    /**
-     * Spend currency from the caller's own wallet. The server refuses to
-     * overdraw. Resolves with the new balance.
-     */
-    async spend(walletId, amount, currency) {
-        return kitInvoke(this.gameModel, {
-            appId: String(this.appId),
-            functionName: economyCurrencyFn('spend', currency ?? this.defaultCurrency, this.typePrefix),
-            selfContainerId: walletId,
-            params: { amount },
-        });
-    }
-    /** Find an existing wallet container id for a user (no creation). */
-    async ensureSellerWallet(sellerUserId) {
-        const wallets = await this.gameModel.containers({
-            appId: this.appId,
-            typeName: this.names.walletType,
-        });
-        const wallet = wallets.find((c) => c.ownerUserId != null && String(c.ownerUserId) === sellerUserId);
-        if (!wallet) {
-            throw new Error(`Seller ${sellerUserId} has no ${this.names.walletType}; they must ensureWallet() before selling`);
-        }
-        return wallet.containerId;
-    }
-    async toTrade(containerId, displayName, ownerUserId) {
-        const props = await kitContainerProperties(this.gameModel, String(this.appId), containerId);
-        return {
-            containerId,
-            displayName,
-            fromUserId: ownerUserId,
-            toUserId: Number(props.to_user_id ?? 0),
-            giveStackId: String(props.give_stack_id ?? ''),
-            receiveStackId: String(props.receive_stack_id ?? ''),
-            giveItemId: String(props.give_item_id ?? ''),
-            giveQty: Number(props.give_qty ?? 0),
-            wantItemId: String(props.want_item_id ?? ''),
-            wantQty: Number(props.want_qty ?? 0),
-            status: String(props.status ?? ''),
-        };
-    }
-}
-/**
- * Order-book market methods over the market-engine (Wave 2): price-time
- * priority matching with escrowed settlement. Deposits/withdrawals bridge
- * to the game's wallets via compute events the game layer consumes.
- *
- * Obtained via `client.kit(appId).economy.market`.
- */
-export class MarketKit {
-    constructor(engines, moduleName) {
-        this.engines = engines;
-        this.moduleName = moduleName;
-    }
-    /** Is the market engine deployed + enabled (cached per session)? */
-    engineAvailable() {
-        if (!this.engines)
-            return Promise.resolve(false);
-        return this.engines.has(this.moduleName);
-    }
-    /** Move coins into your market account (escrow source for bids). */
-    async depositCoins(amount) {
-        return this.invoke('deposit_coins', { amount });
-    }
-    /** Move items into your market account (escrow source for asks). */
-    async depositItems(item, quantity) {
-        return this.invoke('deposit_items', { item, quantity });
-    }
-    /** Place a limit bid: locks coins at your limit; fills at maker price. */
-    async bid(item, price, quantity) {
-        return this.invoke('place', { item, side: 'buy', price, quantity });
-    }
-    /** Place a limit ask: locks items until filled or cancelled. */
-    async ask(item, price, quantity) {
-        return this.invoke('place', { item, side: 'sell', price, quantity });
-    }
-    /** Cancel a resting order (owner only); escrow refunds instantly. */
-    async cancel(item, orderId) {
-        return this.invoke('cancel', { item, orderId });
-    }
-    /** Book depth: best bids/asks as [price, quantity] levels. */
-    async book(item) {
-        return this.invoke('book', { item });
-    }
-    /** Your market account (settled + locked balances). */
-    async account() {
-        return this.invoke('account', {});
-    }
-    /** Withdraw settled balances back to the game layer. */
-    async withdraw(input) {
-        return this.invoke('withdraw', input);
-    }
-    async invoke(exportName, params) {
-        if (!this.engines) {
-            throw new Error('market engine unavailable: compute domain not wired');
-        }
-        const result = await this.engines.invoke(this.moduleName, exportName, params);
-        if (!result.success) {
-            throw new Error(`market.${exportName} failed: ${result.reason ?? 'unknown'}`);
-        }
-        return result.body;
-    }
-}

package/dist/kit/engine.d.ts

@@ -1,48 +0,0 @@
-/**
- * Compute-engine capability detection + invoke envelope for the kit helpers.
- * Games deploy engines (mob-engine, world-engine, bwf-mobs, ...) as compute
- * modules; kit helpers probe once per module per session and route through
- * the engine when it is present, falling back to the model/automation path
- * when it is not — so the same client code works on model-only deployments.
- */
-import type { ComputeAPI } from '../domains/compute.js';
-/** The `{success, ...}` envelope engine invoke exports resolve with. */
-export interface EngineInvokeResult<T = Record<string, unknown>> {
-    success: boolean;
-    /** The engine's denial reason when `success` is false. */
-    reason?: string;
-    /** The parsed result body (includes any extra fields the export returns). */
-    body: T & Record<string, unknown>;
-    fuelUsed?: string;
-    durationUs?: number;
-}
-/**
- * Per-session cached probe of which compute modules an app has enabled.
- * Obtained internally by kit helpers; share one via `kit.engines`.
- */
-export declare class EngineDetector {
-    private readonly appId;
-    private readonly compute;
-    private readonly cache;
-    constructor(appId: string, compute: ComputeAPI | undefined);
-    /**
-     * Is `moduleName` deployed + enabled? Cached per module for the client's
-     * lifetime ({@link reset} to re-probe after deploys). Resolves false when
-     * the client has no compute domain wired.
-     */
-    has(moduleName: string): Promise<boolean>;
-    /** Drop cached probes (call after deploying/enabling modules). */
-    reset(): void;
-    /**
-     * Invoke an engine export and parse the `{success, ...}` envelope.
-     * Envelope failures (denials) resolve; every GraphQL-level error
-     * (invoke-policy FORBIDDEN, the typed invoke-contract violation —
-     * `BAD_REQUEST` "Invoke params violate ..." — a disabled module, ...) also
-     * resolves as `{ success: false, reason }` so kit callers always get
-     * gameplay-verdict semantics from compute invokes. Only non-GraphQL
-     * (transport) errors throw.
-     */
-    invoke<T = Record<string, unknown>>(moduleName: string, exportName: string, params?: Record<string, unknown>): Promise<EngineInvokeResult<T>>;
-    private probe;
-}
-//# sourceMappingURL=engine.d.ts.map

package/dist/kit/engine.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/kit/engine.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAExD,wEAAwE;AACxE,MAAM,WAAW,kBAAkB,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC7D,OAAO,EAAE,OAAO,CAAC;IACjB,0DAA0D;IAC1D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6EAA6E;IAC7E,IAAI,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;GAGG;AACH,qBAAa,cAAc;IAIvB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJ1B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAuC;gBAG1C,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,UAAU,GAAG,SAAS;IAGlD;;;;OAIG;IACH,GAAG,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAUzC,kEAAkE;IAClE,KAAK,IAAI,IAAI;IAIb;;;;;;;;OAQG;IACG,MAAM,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACtC,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC/B,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC;YAwCnB,KAAK;CAmBpB"}

package/dist/kit/engine.js

@@ -1,113 +0,0 @@
-/**
- * Compute-engine capability detection + invoke envelope for the kit helpers.
- * Games deploy engines (mob-engine, world-engine, bwf-mobs, ...) as compute
- * modules; kit helpers probe once per module per session and route through
- * the engine when it is present, falling back to the model/automation path
- * when it is not — so the same client code works on model-only deployments.
- */
-import { CrowdyGraphQLError } from '../errors.js';
-/**
- * Per-session cached probe of which compute modules an app has enabled.
- * Obtained internally by kit helpers; share one via `kit.engines`.
- */
-export class EngineDetector {
-    constructor(appId, compute) {
-        this.appId = appId;
-        this.compute = compute;
-        this.cache = new Map();
-    }
-    /**
-     * Is `moduleName` deployed + enabled? Cached per module for the client's
-     * lifetime ({@link reset} to re-probe after deploys). Resolves false when
-     * the client has no compute domain wired.
-     */
-    has(moduleName) {
-        if (!this.compute)
-            return Promise.resolve(false);
-        let probe = this.cache.get(moduleName);
-        if (!probe) {
-            probe = this.probe(moduleName);
-            this.cache.set(moduleName, probe);
-        }
-        return probe;
-    }
-    /** Drop cached probes (call after deploying/enabling modules). */
-    reset() {
-        this.cache.clear();
-    }
-    /**
-     * Invoke an engine export and parse the `{success, ...}` envelope.
-     * Envelope failures (denials) resolve; every GraphQL-level error
-     * (invoke-policy FORBIDDEN, the typed invoke-contract violation —
-     * `BAD_REQUEST` "Invoke params violate ..." — a disabled module, ...) also
-     * resolves as `{ success: false, reason }` so kit callers always get
-     * gameplay-verdict semantics from compute invokes. Only non-GraphQL
-     * (transport) errors throw.
-     */
-    async invoke(moduleName, exportName, params) {
-        if (!this.compute) {
-            return {
-                success: false,
-                reason: 'compute domain unavailable',
-                body: {},
-            };
-        }
-        try {
-            const result = await this.compute.invoke({
-                appId: this.appId,
-                moduleName,
-                exportName,
-                ...(params !== undefined ? { paramsJson: JSON.stringify(params) } : {}),
-            });
-            let body = {};
-            try {
-                body = JSON.parse(result.resultJson ?? '{}');
-            }
-            catch {
-                body = {};
-            }
-            return {
-                success: body.success !== false,
-                reason: typeof body.reason === 'string' ? body.reason : undefined,
-                body: body,
-                fuelUsed: result.fuelUsed != null ? String(result.fuelUsed) : undefined,
-                durationUs: result.durationUs != null ? Number(result.durationUs) : undefined,
-            };
-        }
-        catch (error) {
-            if (error instanceof CrowdyGraphQLError) {
-                return {
-                    success: false,
-                    reason: error.message,
-                    body: {},
-                };
-            }
-            throw error;
-        }
-    }
-    async probe(moduleName) {
-        if (!this.compute)
-            return false;
-        try {
-            const module = await this.compute.module({ appId: this.appId, name: moduleName });
-            return module != null && module.enabled === true;
-        }
-        catch (error) {
-            if (!(error instanceof CrowdyGraphQLError))
-                throw error;
-            if (error.code !== 'FORBIDDEN')
-                return false;
-        }
-        // Player tokens lack view_compute_diagnostics: probe via a status invoke
-        // (engines all export one). Missing modules reject; denials mean present.
-        try {
-            const result = await this.invoke(moduleName, 'status');
-            if (result.success)
-                return true;
-            return !/not found|no such module|not enabled/i.test(result.reason ?? '');
-        }
-        catch {
-            return false;
-        }
-    }
-}

package/dist/kit/features.d.ts

@@ -1,60 +0,0 @@
-import type { GameModelAPI } from '../domains/gameModel.js';
-import type { Scalars } from '../generated/graphql.js';
-import type { KitInvokePolicy } from './blueprints/index.js';
-/**
- * Runtime **monetization** helpers — the app feature/tier surface in shop
- * terms. Features are string keys (`'vip'`, `'land_owner'`, `'battle_pass'`)
- * defined per app and granted to **access tiers** (the management-side
- * `appAccess` tiers players buy/hold); any model function whose policy
- * carries a `tier_feature` leaf then admits only players on a granted tier.
- *
- * Gate blueprint functions by composing {@link gate} (=`featureGate`) into a
- * builder's `*policyExtra` option, e.g.
- * `plotBlueprint({ buyPolicyExtra: kit.features.gate('land_owner') })`.
- *
- * All methods require the app-admin `manage_apps` permission.
- *
- * Obtained via `client.kit(appId).features`.
- */
-export declare class FeaturesKit {
-    private readonly appId;
-    private readonly gameModel;
-    constructor(appId: Scalars['BigInt']['input'], gameModel: GameModelAPI);
-    /** Define (or re-describe) a feature key for the app. */
-    define(featureKey: string, description?: string): Promise<{
-        __typename?: "GmAppFeature";
-        appId: string;
-        featureKey: string;
-        description: string | null;
-    }>;
-    /** List the app's defined feature keys. */
-    list(): Promise<{
-        __typename?: "GmAppFeature";
-        appId: string;
-        featureKey: string;
-        description: string | null;
-    }[]>;
-    /** Grant a feature to an access tier (its holders pass `tier_feature` checks). */
-    grantToTier(tierId: Scalars['BigInt']['input'], featureKey: string): Promise<{
-        __typename?: "GmTierFeature";
-        appId: string;
-        tierId: string;
-        featureKey: string;
-    }>;
-    /** Revoke a feature from an access tier. */
-    revokeFromTier(tierId: Scalars['BigInt']['input'], featureKey: string): Promise<boolean>;
-    /** List tier→feature grants (optionally for one tier). */
-    tierFeatures(tierId?: Scalars['BigInt']['input']): Promise<{
-        __typename?: "GmTierFeature";
-        appId: string;
-        tierId: string;
-        featureKey: string;
-    }[]>;
-    /**
-     * A `tier_feature` policy leaf for `feature` — pass it to any blueprint
-     * builder's `*policyExtra` option to monetization-gate that function.
-     * (Also exported standalone as `featureGate`.)
-     */
-    gate(feature: string): KitInvokePolicy;
-}
-//# sourceMappingURL=features.d.ts.map

package/dist/kit/features.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"features.d.ts","sourceRoot":"","sources":["../../src/kit/features.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAEvD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D;;;;;;;;;;;;;;GAcG;AACH,qBAAa,WAAW;IAEpB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,SAAS;gBADT,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,EACjC,SAAS,EAAE,YAAY;IAG1C,yDAAyD;IACnD,MAAM,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM;;;;;;IAQrD,2CAA2C;IACrC,IAAI;;;;;;IAIV,kFAAkF;IAC5E,WAAW,CACf,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,EAClC,UAAU,EAAE,MAAM;;;;;;IASpB,4CAA4C;IACtC,cAAc,CAClB,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,EAClC,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,OAAO,CAAC;IAQnB,0DAA0D;IACpD,YAAY,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC;;;;;;IAOtD;;;;OAIG;IACH,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe;CAGvC"}