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

package/dist/kit/blueprints/index.js

@@ -1,22 +0,0 @@
-/**
- * Blueprint builders for the Game Kit, one module per game concept, re-exported
- * here as a stable barrel (import paths from `kit/index.js` and the package
- * root are unchanged as builders are added).
- */
-export { andPolicies, composeBlueprints, featureGate, kitPolicyJson, mergeBlueprints, ownerEquals, ownerEqualsCaller, ownerMirrorProperty, toSnakeCase, trustedAuthorityFields, } from './core.js';
-export { combatBlueprint, combatNames, } from './combat.js';
-export { decksBlueprint, decksNames, } from './decks.js';
-export { economyBlueprint, economyCurrencyFn, economyNames, } from './economy.js';
-export { guildBlueprint, guildNames, } from './guild.js';
-export { inventoryBlueprint, inventoryBarterFunctionName, inventoryCraftFunctionName, inventoryNames, } from './inventory.js';
-export { leaderboardsBlueprint, leaderboardsNames, } from './leaderboards.js';
-export { lootBlueprint, lootNames, lootRollFn, } from './loot.js';
-export { lockBlueprint, lockNames, } from './locks.js';
-export { questsBlueprint, questsNames, } from './quests.js';
-export { progressionBlueprint, progressionNames, } from './progression.js';
-export { plotBlueprint, plotNames, } from './plots.js';
-export { matchesBlueprint, matchesNames, } from './matches.js';
-export { npcBehaviorFunctionName, npcBlueprint, } from './npcs.js';
-export { worldsimBlueprint, worldsimNames, } from './worldsim.js';
-export { liveopsBlueprint, liveopsNames, } from './liveops.js';
-export { moderationBlueprint, moderationNames, } from './moderation.js';

package/dist/kit/blueprints/inventory.d.ts

@@ -1,84 +0,0 @@
-import { type KitBlueprint, type KitOwnerIdKind } from './core.js';
-/** Options for {@link inventoryBlueprint}. */
-export interface InventoryBlueprintOptions {
-    /**
-     * Prefix applied to the container type names (e.g. `'Bank'` →
-     * `BankInventory` / `BankItemStack`) and, snake-cased, to the function
-     * names (`bank_grant_stack`, …). Lets several independent inventory systems
-     * coexist in one app. Defaults to none.
-     */
-    typePrefix?: string;
-    /** Default `max_slots` on new inventories. Defaults to 24. */
-    maxSlots?: number;
-    /** Exclusive upper bound for stack `slot` indexes. Defaults to 64. */
-    slotCount?: number;
-    /**
-     * Recipes compiled into atomic Model functions. Each generated function
-     * consumes every input stack and grants the output stack in ONE
-     * transaction; all refs must be caller-owned and item ids must match.
-     */
-    recipes?: InventoryRecipeSpec[];
-    /** Item-for-item offers compiled into atomic barter functions. */
-    barters?: InventoryBarterSpec[];
-    /** Owner mirror representation. Defaults to `int`; legacy worlds may use `string`. */
-    ownerIdKind?: KitOwnerIdKind;
-    /**
-     * Who may instantiate ItemStack rows. Defaults to `member` for backwards
-     * compatibility; competitive games should use `admin` and create empty
-     * stacks through a trusted compute/bootstrap path.
-     */
-    stackInstantiableBy?: 'member' | 'admin';
-    /**
-     * Who may call the generic grant function. `owner` preserves the original
-     * sandbox-friendly behavior; competitive games should use `server` and
-     * grant only through trusted transactions/referees.
-     */
-    grantAuthority?: 'owner' | 'server';
-}
-export interface InventoryRecipeSpec {
-    recipeId: string;
-    inputs: Array<{
-        itemId: string;
-        quantity: number;
-    }>;
-    output: {
-        itemId: string;
-        quantity: number;
-    };
-}
-export interface InventoryBarterSpec {
-    barterId: string;
-    pay: {
-        itemId: string;
-        quantity: number;
-    };
-    receive: {
-        itemId: string;
-        quantity: number;
-    };
-}
-export declare function inventoryCraftFunctionName(recipeId: string, typePrefix?: string): string;
-export declare function inventoryBarterFunctionName(barterId: string, typePrefix?: string): string;
-/** Names derived by {@link inventoryBlueprint} for a given prefix. */
-export interface InventoryNames {
-    inventoryType: string;
-    stackType: string;
-    grantFn: string;
-    consumeFn: string;
-    moveFn: string;
-    transferFn: string;
-    containsEdge: string;
-}
-/** Compute the type/function names an inventory blueprint (and its runtime helper) uses. */
-export declare function inventoryNames(typePrefix?: string): InventoryNames;
-/**
- * Blueprint for a server-authoritative **inventory**: a per-player
- * `Inventory` container plus `ItemStack` containers (`item_id`, `quantity`,
- * `slot`), and owner-gated functions to grant, consume, move, and transfer
- * stacks. Quantity guards live in the invoke policies, so an untrusted client
- * can never overdraw or touch another player's items.
- *
- * Runtime counterpart: `client.kit(appId).inventory`.
- */
-export declare function inventoryBlueprint(options?: InventoryBlueprintOptions): KitBlueprint;
-//# sourceMappingURL=inventory.d.ts.map

package/dist/kit/blueprints/inventory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"inventory.d.ts","sourceRoot":"","sources":["../../../src/kit/blueprints/inventory.ts"],"names":[],"mappings":"AACA,OAAO,EAKL,KAAK,YAAY,EACjB,KAAK,cAAc,EACpB,MAAM,WAAW,CAAC;AAEnB,8CAA8C;AAC9C,MAAM,WAAW,yBAAyB;IACxC;;;;;OAKG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,sEAAsE;IACtE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,OAAO,CAAC,EAAE,mBAAmB,EAAE,CAAC;IAChC,kEAAkE;IAClE,OAAO,CAAC,EAAE,mBAAmB,EAAE,CAAC;IAChC,sFAAsF;IACtF,WAAW,CAAC,EAAE,cAAc,CAAC;IAC7B;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC;IACzC;;;;OAIG;IACH,cAAc,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC;CACrC;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACpD,MAAM,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;CAC9C;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1C,OAAO,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;CAC/C;AAED,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,GAAG,MAAM,CAGpF;AAED,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,GAAG,MAAM,CAGrF;AAED,sEAAsE;AACtE,MAAM,WAAW,cAAc;IAC7B,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,4FAA4F;AAC5F,wBAAgB,cAAc,CAAC,UAAU,SAAK,GAAG,cAAc,CAW9D;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,GAAE,yBAA8B,GACtC,YAAY,CAiPd"}

package/dist/kit/blueprints/inventory.js

@@ -1,257 +0,0 @@
-import { kitPolicyJson, ownerEqualsCaller, ownerMirrorProperty, toSnakeCase, } from './core.js';
-export function inventoryCraftFunctionName(recipeId, typePrefix = '') {
-    const prefix = typePrefix ? `${toSnakeCase(typePrefix)}_` : '';
-    return `${prefix}craft_${toSnakeCase(recipeId)}`;
-}
-export function inventoryBarterFunctionName(barterId, typePrefix = '') {
-    const prefix = typePrefix ? `${toSnakeCase(typePrefix)}_` : '';
-    return `${prefix}barter_${toSnakeCase(barterId)}`;
-}
-/** Compute the type/function names an inventory blueprint (and its runtime helper) uses. */
-export function inventoryNames(typePrefix = '') {
-    const fnPrefix = typePrefix ? `${toSnakeCase(typePrefix)}_` : '';
-    return {
-        inventoryType: `${typePrefix}Inventory`,
-        stackType: `${typePrefix}ItemStack`,
-        grantFn: `${fnPrefix}grant_stack`,
-        consumeFn: `${fnPrefix}consume_stack`,
-        moveFn: `${fnPrefix}move_stack`,
-        transferFn: `${fnPrefix}transfer_stack`,
-        containsEdge: 'inventory_contains',
-    };
-}
-/**
- * Blueprint for a server-authoritative **inventory**: a per-player
- * `Inventory` container plus `ItemStack` containers (`item_id`, `quantity`,
- * `slot`), and owner-gated functions to grant, consume, move, and transfer
- * stacks. Quantity guards live in the invoke policies, so an untrusted client
- * can never overdraw or touch another player's items.
- *
- * Runtime counterpart: `client.kit(appId).inventory`.
- */
-export function inventoryBlueprint(options = {}) {
-    const { typePrefix = '', maxSlots = 24, slotCount = 64, recipes = [], barters = [], ownerIdKind = 'int', stackInstantiableBy = 'member', grantAuthority = 'owner', } = options;
-    const names = inventoryNames(typePrefix);
-    const ownerOnly = kitPolicyJson({ type: 'owner_of_self' });
-    for (const recipe of recipes) {
-        if (recipe.inputs.length === 0 || recipe.inputs.length > 6) {
-            throw new Error(`inventory recipe '${recipe.recipeId}' must have 1-6 inputs`);
-        }
-    }
-    const recipeFunctions = recipes.map((recipe) => {
-        const inputParams = recipe.inputs.map((_, index) => ({
-            name: `input_${index}_id`,
-            valueType: 'container_ref',
-            required: true,
-        }));
-        const guards = recipe.inputs.flatMap((input, index) => [
-            ownerEqualsCaller(`ref($input_${index}_id).owner_user_id`, ownerIdKind),
-            `ref($input_${index}_id).item_id == "${input.itemId}"`,
-            `ref($input_${index}_id).quantity >= ${input.quantity}`,
-        ]);
-        guards.push(ownerEqualsCaller('ref($output_id).owner_user_id', ownerIdKind));
-        guards.push(`ref($output_id).item_id == "${recipe.output.itemId}"`);
-        return {
-            name: inventoryCraftFunctionName(recipe.recipeId, typePrefix),
-            containerTypeName: names.inventoryType,
-            returnType: 'int',
-            parameters: [
-                ...inputParams,
-                { name: 'output_id', valueType: 'container_ref', required: true },
-            ],
-            mutations: [
-                ...recipe.inputs.map((input, index) => ({
-                    target: `ref($input_${index}_id)`,
-                    property: 'quantity',
-                    expression: `ref($input_${index}_id).quantity - ${input.quantity}`,
-                })),
-                {
-                    target: 'ref($output_id)',
-                    property: 'quantity',
-                    expression: `ref($output_id).quantity + ${recipe.output.quantity}`,
-                },
-            ],
-            returnExpression: 'ref($output_id).quantity',
-            invokePolicyJson: kitPolicyJson({
-                type: 'and',
-                rules: [
-                    { type: 'owner_of_self' },
-                    { type: 'condition', expression: guards.join(' && ') },
-                ],
-            }),
-            autonomousInvocable: true,
-            description: `Atomically craft '${recipe.recipeId}': consume all inputs and grant the output, or write nothing.`,
-        };
-    });
-    const barterFunctions = barters.map((barter) => ({
-        name: inventoryBarterFunctionName(barter.barterId, typePrefix),
-        containerTypeName: names.inventoryType,
-        returnType: 'int',
-        parameters: [
-            { name: 'pay_id', valueType: 'container_ref', required: true },
-            { name: 'receive_id', valueType: 'container_ref', required: true },
-        ],
-        mutations: [
-            {
-                target: 'ref($pay_id)',
-                property: 'quantity',
-                expression: `ref($pay_id).quantity - ${barter.pay.quantity}`,
-            },
-            {
-                target: 'ref($receive_id)',
-                property: 'quantity',
-                expression: `ref($receive_id).quantity + ${barter.receive.quantity}`,
-            },
-        ],
-        returnExpression: 'ref($receive_id).quantity',
-        invokePolicyJson: kitPolicyJson({
-            type: 'and',
-            rules: [
-                { type: 'owner_of_self' },
-                {
-                    type: 'condition',
-                    expression: [
-                        ownerEqualsCaller('ref($pay_id).owner_user_id', ownerIdKind),
-                        `ref($pay_id).item_id == "${barter.pay.itemId}"`,
-                        `ref($pay_id).quantity >= ${barter.pay.quantity}`,
-                        ownerEqualsCaller('ref($receive_id).owner_user_id', ownerIdKind),
-                        `ref($receive_id).item_id == "${barter.receive.itemId}"`,
-                    ].join(' && '),
-                },
-            ],
-        }),
-        autonomousInvocable: true,
-        description: `Atomically execute barter '${barter.barterId}', or write nothing.`,
-    }));
-    return {
-        name: names.inventoryType,
-        containerTypes: [
-            {
-                typeName: names.inventoryType,
-                displayName: names.inventoryType,
-                instantiableBy: 'member',
-                description: 'A bag of item stacks owned by one player.',
-            },
-            {
-                typeName: names.stackType,
-                displayName: names.stackType,
-                instantiableBy: stackInstantiableBy,
-                description: 'One stack of a single item type in an inventory slot.',
-            },
-        ],
-        propertyDefinitions: [
-            {
-                containerTypeName: names.inventoryType,
-                key: 'max_slots',
-                valueType: 'int',
-                defaultValueJson: String(maxSlots),
-            },
-            { containerTypeName: names.stackType, key: 'item_id', valueType: 'string' },
-            ownerMirrorProperty(names.stackType, ownerIdKind),
-            {
-                containerTypeName: names.stackType,
-                key: 'quantity',
-                valueType: 'int',
-                defaultValueJson: '0',
-            },
-            {
-                containerTypeName: names.stackType,
-                key: 'slot',
-                valueType: 'int',
-                defaultValueJson: '0',
-            },
-        ],
-        functions: [
-            {
-                name: names.grantFn,
-                containerTypeName: names.stackType,
-                returnType: 'int',
-                parameters: [{ name: 'amount', valueType: 'int', required: true }],
-                mutations: [
-                    {
-                        target: 'self',
-                        property: 'quantity',
-                        expression: 'self.quantity + max(0, $amount)',
-                    },
-                ],
-                returnExpression: 'self.quantity',
-                invokePolicyJson: grantAuthority === 'server'
-                    ? kitPolicyJson({ type: 'is_automation' })
-                    : ownerOnly,
-                invokeScope: grantAuthority === 'server' ? 'internal' : undefined,
-                autonomousInvocable: grantAuthority === 'server' ? true : undefined,
-                description: grantAuthority === 'server'
-                    ? 'Trusted server/compute grant; players cannot mint items.'
-                    : 'Add items to a stack the caller owns.',
-            },
-            {
-                name: names.consumeFn,
-                containerTypeName: names.stackType,
-                returnType: 'int',
-                parameters: [{ name: 'amount', valueType: 'int', required: true }],
-                mutations: [
-                    { target: 'self', property: 'quantity', expression: 'self.quantity - $amount' },
-                ],
-                returnExpression: 'self.quantity',
-                invokePolicyJson: kitPolicyJson({
-                    type: 'and',
-                    rules: [
-                        { type: 'owner_of_self' },
-                        {
-                            type: 'condition',
-                            expression: '$amount > 0 && self.quantity >= $amount',
-                        },
-                    ],
-                }),
-                description: 'Spend items from a stack; refuses to overdraw.',
-            },
-            {
-                name: names.moveFn,
-                containerTypeName: names.stackType,
-                returnType: 'int',
-                parameters: [{ name: 'to_slot', valueType: 'int', required: true }],
-                mutations: [
-                    {
-                        target: 'self',
-                        property: 'slot',
-                        expression: `clamp($to_slot, 0, ${slotCount - 1})`,
-                    },
-                ],
-                returnExpression: 'self.slot',
-                invokePolicyJson: ownerOnly,
-                description: 'Move a stack to another slot.',
-            },
-            {
-                name: names.transferFn,
-                containerTypeName: names.stackType,
-                returnType: 'int',
-                parameters: [
-                    { name: 'to_id', valueType: 'container_ref', required: true },
-                    { name: 'amount', valueType: 'int', required: true },
-                ],
-                mutations: [
-                    { target: 'self', property: 'quantity', expression: 'self.quantity - $amount' },
-                    {
-                        target: 'ref($to_id)',
-                        property: 'quantity',
-                        expression: 'ref($to_id).quantity + $amount',
-                    },
-                ],
-                returnExpression: 'self.quantity',
-                invokePolicyJson: kitPolicyJson({
-                    type: 'and',
-                    rules: [
-                        { type: 'owner_of_self' },
-                        {
-                            type: 'condition',
-                            expression: '$amount > 0 && self.quantity >= $amount && ref($to_id).item_id == self.item_id',
-                        },
-                    ],
-                }),
-                description: 'Atomically move items between two stacks of the same item type.',
-            },
-            ...recipeFunctions,
-            ...barterFunctions,
-        ],
-    };
-}

package/dist/kit/blueprints/leaderboards.d.ts

@@ -1,49 +0,0 @@
-import { type KitBlueprint, type KitOwnerIdKind, type KitTrustedAuthority } from './core.js';
-/** Options for {@link leaderboardsBlueprint}. */
-export interface LeaderboardsBlueprintOptions {
-    /** Prefix for the type/function names. Defaults to none. */
-    typePrefix?: string;
-    /**
-     * Who may submit scores: `'host'` (the elected host referees; default),
-     * `'server'` (app admins / studio backend), or `'automation'` (e.g. an
-     * event automation on the match layer's `end_match`).
-     */
-    submitAuthority?: KitTrustedAuthority;
-    /**
-     * When true (default), submitting keeps the best score
-     * (`max(self.score, $points)`); when false, submissions overwrite.
-     */
-    keepBest?: boolean;
-    /**
-     * When set, adds a cron automation that rolls the season: bumps `season`
-     * and resets `score`/`rank` on EVERY entry (e.g. `'0 0 1 * *'` for
-     * monthly seasons).
-     */
-    seasonCron?: string;
-    /** Owner-mirror typing (see the kit convention). Defaults to `'int'`. */
-    ownerIdKind?: KitOwnerIdKind;
-}
-/** Names derived by {@link leaderboardsBlueprint} for a given prefix. */
-export interface LeaderboardsNames {
-    entryType: string;
-    submitFn: string;
-    rollSeasonFn: string;
-    seasonAutomation: string;
-}
-/** Compute the type/function names a leaderboards blueprint (and its runtime helper) uses. */
-export declare function leaderboardsNames(typePrefix?: string): LeaderboardsNames;
-/**
- * Blueprint for **leaderboards**: per-player `LeaderboardEntry` rows keyed
- * by a `board_id`, written only through the trusted `submit_score`
- * (host-refereed by default — configure `submitAuthority`), with optional
- * cron **season rolls**.
- *
- * Ranking is honest about the platform: container lists have no server-side
- * ORDER BY, so `kit.leaderboards.top()` fetches a board's entries and sorts
- * client-side — fine for the few hundred entries a per-app board holds.
- * Automation selectors' `pick: highest` covers server-side top-1 needs.
- *
- * Runtime counterpart: `client.kit(appId).leaderboards`.
- */
-export declare function leaderboardsBlueprint(options?: LeaderboardsBlueprintOptions): KitBlueprint;
-//# sourceMappingURL=leaderboards.d.ts.map

package/dist/kit/blueprints/leaderboards.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"leaderboards.d.ts","sourceRoot":"","sources":["../../../src/kit/blueprints/leaderboards.ts"],"names":[],"mappings":"AAIA,OAAO,EAML,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACzB,MAAM,WAAW,CAAC;AAEnB,iDAAiD;AACjD,MAAM,WAAW,4BAA4B;IAC3C,4DAA4D;IAC5D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,eAAe,CAAC,EAAE,mBAAmB,CAAC;IACtC;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,yEAAyE;IACzE,WAAW,CAAC,EAAE,cAAc,CAAC;CAC9B;AAED,yEAAyE;AACzE,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,8FAA8F;AAC9F,wBAAgB,iBAAiB,CAAC,UAAU,SAAK,GAAG,iBAAiB,CAQpE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,GAAE,4BAAiC,GACzC,YAAY,CAiHd"}

package/dist/kit/blueprints/leaderboards.js

@@ -1,126 +0,0 @@
-import { kitPolicyJson, ownerMirrorProperty, toSnakeCase, trustedAuthorityFields, } from './core.js';
-/** Compute the type/function names a leaderboards blueprint (and its runtime helper) uses. */
-export function leaderboardsNames(typePrefix = '') {
-    const fnPrefix = typePrefix ? `${toSnakeCase(typePrefix)}_` : '';
-    return {
-        entryType: `${typePrefix}LeaderboardEntry`,
-        submitFn: `${fnPrefix}submit_score`,
-        rollSeasonFn: `${fnPrefix}roll_season`,
-        seasonAutomation: `${fnPrefix.replace(/_/g, '-')}season-roll`,
-    };
-}
-/**
- * Blueprint for **leaderboards**: per-player `LeaderboardEntry` rows keyed
- * by a `board_id`, written only through the trusted `submit_score`
- * (host-refereed by default — configure `submitAuthority`), with optional
- * cron **season rolls**.
- *
- * Ranking is honest about the platform: container lists have no server-side
- * ORDER BY, so `kit.leaderboards.top()` fetches a board's entries and sorts
- * client-side — fine for the few hundred entries a per-app board holds.
- * Automation selectors' `pick: highest` covers server-side top-1 needs.
- *
- * Runtime counterpart: `client.kit(appId).leaderboards`.
- */
-export function leaderboardsBlueprint(options = {}) {
-    const { typePrefix = '', submitAuthority = 'host', keepBest = true, seasonCron, ownerIdKind: kind = 'int', } = options;
-    const names = leaderboardsNames(typePrefix);
-    const propertyDefinitions = [
-        ownerMirrorProperty(names.entryType, kind),
-        {
-            containerTypeName: names.entryType,
-            key: 'board_id',
-            valueType: 'string',
-            defaultValueJson: '""',
-            description: "Which leaderboard this entry belongs to (e.g. 'weekly_kills').",
-        },
-        {
-            containerTypeName: names.entryType,
-            key: 'score',
-            valueType: 'int',
-            defaultValueJson: '0',
-            description: 'The ranked score, written only through submit_score.',
-        },
-        {
-            containerTypeName: names.entryType,
-            key: 'season',
-            valueType: 'int',
-            defaultValueJson: '1',
-            description: 'Season counter, bumped by the season-roll automation.',
-        },
-        {
-            containerTypeName: names.entryType,
-            key: 'rank',
-            valueType: 'int',
-            defaultValueJson: '0',
-            description: 'Optional stamped rank (0 = unstamped; ranking is client-side by default).',
-        },
-    ];
-    const functions = [
-        {
-            name: names.submitFn,
-            containerTypeName: names.entryType,
-            returnType: 'int',
-            parameters: [
-                {
-                    name: 'points',
-                    valueType: 'int',
-                    required: true,
-                    description: 'The score to submit.',
-                },
-            ],
-            mutations: [
-                {
-                    target: 'self',
-                    property: 'score',
-                    expression: keepBest ? 'max(self.score, $points)' : '$points',
-                },
-            ],
-            returnExpression: 'self.score',
-            ...trustedAuthorityFields(submitAuthority),
-            description: `Trusted score submission (${keepBest ? 'keeps the best score' : 'overwrites'}); never a plain player call.`,
-        },
-    ];
-    const automations = [];
-    if (seasonCron !== undefined) {
-        functions.push({
-            name: names.rollSeasonFn,
-            containerTypeName: names.entryType,
-            returnType: 'int',
-            mutations: [
-                { target: 'self', property: 'season', expression: 'self.season + 1' },
-                { target: 'self', property: 'score', expression: '0' },
-                { target: 'self', property: 'rank', expression: '0' },
-            ],
-            returnExpression: 'self.season',
-            invokePolicyJson: kitPolicyJson({ type: 'is_automation' }),
-            autonomousInvocable: true,
-            description: 'Season roll (automation-only): bumps the season and resets scores.',
-        });
-        automations.push({
-            name: names.seasonAutomation,
-            functionName: names.rollSeasonFn,
-            targetMode: 'type',
-            targetTypeName: names.entryType,
-            triggerType: 'schedule',
-            scheduleKind: 'cron',
-            cronExpr: seasonCron,
-            maxTargets: 500,
-            description: 'Rolls every leaderboard entry into the next season on the cron.',
-        });
-    }
-    return {
-        name: names.entryType,
-        containerTypes: [
-            {
-                typeName: names.entryType,
-                displayName: names.entryType,
-                instantiableBy: 'member',
-                description: "One player's entry on one leaderboard (score writable only via submit_score).",
-            },
-        ],
-        propertyDefinitions,
-        functions,
-        ...(automations.length ? { automations } : {}),
-    };
-}

package/dist/kit/blueprints/liveops.d.ts

@@ -1,42 +0,0 @@
-import { type KitBlueprint, type KitTrustedAuthority } from './core.js';
-/** Options for {@link liveopsBlueprint}. */
-export interface LiveopsBlueprintOptions {
-    /** Prefix for the type/function names. Defaults to none. */
-    typePrefix?: string;
-    /**
-     * Who may open/close windows and roll seasons: `'server'` (app admins /
-     * studio backend; default) or `'automation'` (cron-driven flips).
-     */
-    adminAuthority?: KitTrustedAuthority;
-}
-/** Names derived by {@link liveopsBlueprint} for a given prefix. */
-export interface LiveopsNames {
-    windowType: string;
-    seasonType: string;
-    openWindowFn: string;
-    closeWindowFn: string;
-    activateSeasonFn: string;
-}
-/** Compute the type/function names a liveops blueprint (and its runtime helper) uses. */
-export declare function liveopsNames(typePrefix?: string): LiveopsNames;
-/**
- * Blueprint for **liveops** (matrix P4, P3): event windows, seasons, and
- * battle-pass composition — MODEL-FIRST (the coexistence policy):
- *
- * - `EventWindow` containers carry a `window_id`, an `active` flag, optional
- *   `opens_at_ms`/`closes_at_ms` timestamps, and an opaque `modifiers` JSON
- *   blob. Admin (or cron-automation) functions flip `active`; when both
- *   timestamps are set, the **liveops-scheduler compute engine** flips the
- *   flag itself and broadcasts the modifiers on the compute bus
- *   (`liveops_window_opened`/`closed`) for other engines to apply — spawn
- *   multipliers, weather locks, double gold.
- * - `SeasonDef` containers name a season (`season_id`, `active`,
- *   `starts_at_ms`/`ends_at_ms`) and its battle-pass composition: the
- *   `pass_track` is a progression-layer track name and `pass_features` a
- *   JSON array of feature gates unlocked per tier — a battle pass is a
- *   SEASON + PROGRESSION TRACK + FEATURE GATES, no new machinery.
- *
- * Runtime counterpart: `client.kit(appId).liveops`.
- */
-export declare function liveopsBlueprint(options?: LiveopsBlueprintOptions): KitBlueprint;
-//# sourceMappingURL=liveops.d.ts.map

package/dist/kit/blueprints/liveops.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"liveops.d.ts","sourceRoot":"","sources":["../../../src/kit/blueprints/liveops.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,KAAK,YAAY,EACjB,KAAK,mBAAmB,EACzB,MAAM,WAAW,CAAC;AAEnB,4CAA4C;AAC5C,MAAM,WAAW,uBAAuB;IACtC,4DAA4D;IAC5D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,cAAc,CAAC,EAAE,mBAAmB,CAAC;CACtC;AAED,oEAAoE;AACpE,MAAM,WAAW,YAAY;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,yFAAyF;AACzF,wBAAgB,YAAY,CAAC,UAAU,SAAK,GAAG,YAAY,CAS1D;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,GAAE,uBAA4B,GAAG,YAAY,CAqJpF"}