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

package/dist/kit/blueprints/worldsim.js

@@ -1,468 +0,0 @@
-import { kitPolicyJson, ownerEqualsCaller, ownerMirrorProperty, toSnakeCase, } from './core.js';
-/** Compute the type/function names a worldsim blueprint (and its runtime helper) uses. */
-export function worldsimNames(typePrefix = '') {
-    const fnPrefix = typePrefix ? `${toSnakeCase(typePrefix)}_` : '';
-    const autoPrefix = fnPrefix.replace(/_/g, '-');
-    return {
-        worldStateType: `${typePrefix}WorldState`,
-        nodeType: `${typePrefix}ResourceNode`,
-        cropType: `${typePrefix}Crop`,
-        spawnerType: `${typePrefix}WaveSpawner`,
-        advanceTimeFn: `${fnPrefix}advance_time`,
-        setWeatherFn: `${fnPrefix}set_weather`,
-        regenNodeFn: `${fnPrefix}regen_node`,
-        gatherNodeFn: `${fnPrefix}gather_node`,
-        growCropFn: `${fnPrefix}grow_crop`,
-        harvestFn: `${fnPrefix}harvest`,
-        spawnWaveFn: `${fnPrefix}spawn_wave`,
-        clockAutomation: `${autoPrefix}world-clock`,
-        regenAutomation: `${autoPrefix}node-regen`,
-        growthAutomation: `${autoPrefix}crop-growth`,
-        waveAutomation: `${autoPrefix}wave-spawner`,
-    };
-}
-/**
- * Blueprint for **world simulation**: day/night + weather (`WorldState`
- * singleton), regenerating `ResourceNode`s, growing `Crop`s / production
- * jobs, and `WaveSpawner` counters — all driven by interval automations on the
- * automations simulation tier (seconds, never per-frame).
- *
- * **These automations run only while the app has a player in it.** Since
- * 2026-09-01 scheduled work for an empty app is skipped and rescheduled from the
- * moment a player returns; missed runs are never made up. Design the tick to be
- * IDEMPOTENT IN ELAPSED TIME rather than to assume a fixed cadence: read the
- * clock, advance the world by however long it has been, and write the result. A
- * crop that grows by one step per tick will stall while nobody is playing; one
- * that grows by `now - lastTick` will be correct whenever anybody looks at it.
- *
- * The world clock emits a **spatial notification** at the world anchor chunk
- * each tick, so nearby clients update the sky push-style instead of polling;
- * everything else is pull-on-demand (or wire your own notify-to-pull pings).
- * Wave spawners only advance counters — actual entity spawning belongs on
- * the replication plane under host authority (the BWF hybrid).
- *
- * Runtime counterpart: `client.kit(appId).worldsim`.
- */
-export function worldsimBlueprint(options = {}) {
-    const { typePrefix = '', ownerIdKind: kind = 'int' } = options;
-    const names = worldsimNames(typePrefix);
-    const automationOnly = kitPolicyJson({ type: 'is_automation' });
-    const containerTypes = [];
-    const propertyDefinitions = [];
-    const functions = [];
-    const automations = [];
-    // --- Day/night + weather ---------------------------------------------------
-    if (options.time !== false) {
-        const time = options.time === undefined ? {} : options.time;
-        const hoursPerDay = time.hoursPerDay ?? 24;
-        const weather = time.weather ?? true;
-        const lastHour = hoursPerDay - 1;
-        containerTypes.push({
-            typeName: names.worldStateType,
-            displayName: names.worldStateType,
-            instantiableBy: 'admin',
-            description: 'Singleton world clock/weather state (create one via kit.worldsim.ensureWorld).',
-        });
-        propertyDefinitions.push({
-            containerTypeName: names.worldStateType,
-            key: 'time_of_day',
-            valueType: 'int',
-            defaultValueJson: '0',
-            description: `In-game hour, 0..${lastHour}, advanced by the world-clock automation.`,
-        }, {
-            containerTypeName: names.worldStateType,
-            key: 'day',
-            valueType: 'int',
-            defaultValueJson: '0',
-            description: 'In-game day counter (bumps when the clock wraps).',
-        }, {
-            containerTypeName: names.worldStateType,
-            key: 'weather',
-            valueType: 'string',
-            defaultValueJson: '"clear"',
-            description: "Current weather: 'clear' | 'rain' | 'storm'.",
-        }, {
-            containerTypeName: names.worldStateType,
-            key: 'cx',
-            valueType: 'int',
-            defaultValueJson: '0',
-            description: 'Anchor chunk of the time-changed spatial notification.',
-        }, {
-            containerTypeName: names.worldStateType,
-            key: 'cy',
-            valueType: 'int',
-            defaultValueJson: '0',
-            description: 'Anchor chunk (y).',
-        }, {
-            containerTypeName: names.worldStateType,
-            key: 'cz',
-            valueType: 'int',
-            defaultValueJson: '0',
-            description: 'Anchor chunk (z).',
-        });
-        functions.push({
-            name: names.advanceTimeFn,
-            containerTypeName: names.worldStateType,
-            returnType: 'int',
-            mutations: [
-                {
-                    target: 'self',
-                    property: 'day',
-                    expression: `if(self.time_of_day >= ${lastHour}, self.day + 1, self.day)`,
-                },
-                {
-                    target: 'self',
-                    property: 'time_of_day',
-                    expression: `(self.time_of_day + 1) % ${hoursPerDay}`,
-                },
-                ...(weather
-                    ? [
-                        {
-                            target: 'self',
-                            property: 'weather',
-                            expression: 'if(rand() < 0.7, "clear", if(rand() < 0.5, "rain", "storm"))',
-                        },
-                    ]
-                    : []),
-            ],
-            returnExpression: 'self.time_of_day',
-            invokePolicyJson: automationOnly,
-            autonomousInvocable: true,
-            notifications: [
-                {
-                    kind: 'spatial',
-                    args: [
-                        { name: 'chunk_x', expression: 'self.cx' },
-                        { name: 'chunk_y', expression: 'self.cy' },
-                        { name: 'chunk_z', expression: 'self.cz' },
-                        { name: 'event_type', expression: '1' },
-                        { name: 'state', expression: 'to_string(self.time_of_day)' },
-                        { name: 'distance', expression: String(time.notifyDistance ?? 8) },
-                    ],
-                },
-            ],
-            description: 'World-clock tick (automation-only): advances the hour/day, re-rolls weather, and pushes a spatial time-changed ping so nearby clients skip polling.',
-        });
-        if (weather) {
-            functions.push({
-                name: names.setWeatherFn,
-                containerTypeName: names.worldStateType,
-                returnType: 'string',
-                parameters: [
-                    {
-                        name: 'weather',
-                        valueType: 'string',
-                        required: true,
-                        description: "The weather to force (e.g. 'storm').",
-                    },
-                ],
-                mutations: [
-                    { target: 'self', property: 'weather', expression: '$weather' },
-                ],
-                returnExpression: 'self.weather',
-                // not(allow) denies everyone — app admins bypass invoke policies,
-                // making this an admin-only lever.
-                invokePolicyJson: kitPolicyJson({ type: 'not', rule: { type: 'allow' } }),
-                description: 'Force the weather (app admins only — everyone else is denied).',
-            });
-        }
-        automations.push({
-            name: names.clockAutomation,
-            functionName: names.advanceTimeFn,
-            targetMode: 'type',
-            targetTypeName: names.worldStateType,
-            triggerType: 'schedule',
-            scheduleKind: 'interval',
-            intervalMs: time.intervalMs ?? 60000,
-            maxTargets: 1,
-            description: 'Advances the world clock (and weather) every tick.',
-        });
-    }
-    // --- Resource nodes ----------------------------------------------------------
-    if (options.nodes !== false) {
-        const nodes = options.nodes === undefined ? {} : options.nodes;
-        containerTypes.push({
-            typeName: names.nodeType,
-            displayName: names.nodeType,
-            instantiableBy: 'admin',
-            description: 'A shared harvestable resource node that regenerates server-side.',
-        });
-        propertyDefinitions.push({
-            containerTypeName: names.nodeType,
-            key: 'node_id',
-            valueType: 'string',
-            defaultValueJson: '""',
-            description: 'Stable node identifier.',
-        }, {
-            containerTypeName: names.nodeType,
-            key: 'resource_item_id',
-            valueType: 'string',
-            defaultValueJson: '""',
-            description: 'The item gathering yields (matched against the stack).',
-        }, {
-            containerTypeName: names.nodeType,
-            key: 'amount',
-            valueType: 'int',
-            defaultValueJson: '0',
-            description: 'Units currently available.',
-        }, {
-            containerTypeName: names.nodeType,
-            key: 'max_amount',
-            valueType: 'int',
-            defaultValueJson: '100',
-            description: 'Regeneration ceiling.',
-        }, {
-            containerTypeName: names.nodeType,
-            key: 'regen_rate',
-            valueType: 'int',
-            defaultValueJson: '1',
-            description: 'Units regenerated per tick.',
-        }, {
-            containerTypeName: names.nodeType,
-            key: 'x',
-            valueType: 'float',
-            defaultValueJson: '0',
-            description: 'World position (informational).',
-        }, {
-            containerTypeName: names.nodeType,
-            key: 'y',
-            valueType: 'float',
-            defaultValueJson: '0',
-            description: 'World position.',
-        }, {
-            containerTypeName: names.nodeType,
-            key: 'z',
-            valueType: 'float',
-            defaultValueJson: '0',
-            description: 'World position.',
-        });
-        functions.push({
-            name: names.regenNodeFn,
-            containerTypeName: names.nodeType,
-            returnType: 'int',
-            mutations: [
-                {
-                    target: 'self',
-                    property: 'amount',
-                    expression: 'min(self.max_amount, self.amount + self.regen_rate)',
-                },
-            ],
-            returnExpression: 'self.amount',
-            invokePolicyJson: automationOnly,
-            autonomousInvocable: true,
-            description: 'Server-driven node regeneration tick (automation-only).',
-        }, {
-            name: names.gatherNodeFn,
-            containerTypeName: names.nodeType,
-            returnType: 'int',
-            parameters: [
-                {
-                    name: 'amount',
-                    valueType: 'int',
-                    required: true,
-                    description: 'Units to gather (must not exceed the node amount).',
-                },
-                {
-                    name: 'to_stack_id',
-                    valueType: 'container_ref',
-                    required: true,
-                    description: 'A caller-owned stack of the node resource that receives the units.',
-                },
-            ],
-            mutations: [
-                { target: 'self', property: 'amount', expression: 'self.amount - $amount' },
-                {
-                    target: 'ref($to_stack_id)',
-                    property: 'quantity',
-                    expression: 'ref($to_stack_id).quantity + $amount',
-                },
-            ],
-            returnExpression: 'self.amount',
-            invokePolicyJson: kitPolicyJson({
-                type: 'condition',
-                expression: [
-                    '$amount > 0',
-                    'self.amount >= $amount',
-                    'ref($to_stack_id).item_id == self.resource_item_id',
-                    ownerEqualsCaller('ref($to_stack_id).owner_user_id', kind),
-                ].join(' && '),
-            }),
-            description: 'Gather from a shared node into your stack: the node decrement and the grant commit atomically (no over-gathering races).',
-        });
-        automations.push({
-            name: names.regenAutomation,
-            functionName: names.regenNodeFn,
-            targetMode: 'type',
-            targetTypeName: names.nodeType,
-            triggerType: 'schedule',
-            scheduleKind: 'interval',
-            intervalMs: nodes.intervalMs ?? 60000,
-            maxTargets: 64,
-            selectorJson: JSON.stringify({
-                selfWhere: [{ key: 'amount', op: '<', value: 'self.max_amount' }],
-            }),
-            description: 'Regenerates depleted resource nodes.',
-        });
-    }
-    // --- Crops / production jobs -------------------------------------------------
-    if (options.crops !== false) {
-        const crops = options.crops === undefined ? {} : options.crops;
-        containerTypes.push({
-            typeName: names.cropType,
-            displayName: names.cropType,
-            instantiableBy: 'member',
-            description: 'A planted crop / production job that matures server-side.',
-        });
-        propertyDefinitions.push(ownerMirrorProperty(names.cropType, kind), {
-            containerTypeName: names.cropType,
-            key: 'stage',
-            valueType: 'int',
-            defaultValueJson: '0',
-            description: 'Growth stage, advanced by the crop-growth automation.',
-        }, {
-            containerTypeName: names.cropType,
-            key: 'max_stage',
-            valueType: 'int',
-            defaultValueJson: '3',
-            description: 'Stage at which the crop is harvestable.',
-        }, {
-            containerTypeName: names.cropType,
-            key: 'output_item_id',
-            valueType: 'string',
-            defaultValueJson: '""',
-            description: 'The item harvesting yields.',
-        }, {
-            containerTypeName: names.cropType,
-            key: 'output_qty',
-            valueType: 'int',
-            defaultValueJson: '1',
-            description: 'Units yielded per harvest.',
-        });
-        functions.push({
-            name: names.growCropFn,
-            containerTypeName: names.cropType,
-            returnType: 'int',
-            mutations: [
-                {
-                    target: 'self',
-                    property: 'stage',
-                    expression: 'min(self.stage + 1, self.max_stage)',
-                },
-            ],
-            returnExpression: 'self.stage',
-            invokePolicyJson: automationOnly,
-            autonomousInvocable: true,
-            description: 'Server-driven growth tick (automation-only).',
-        }, {
-            name: names.harvestFn,
-            containerTypeName: names.cropType,
-            returnType: 'int',
-            parameters: [
-                {
-                    name: 'to_stack_id',
-                    valueType: 'container_ref',
-                    required: true,
-                    description: 'A caller-owned stack of the output item that receives the yield.',
-                },
-            ],
-            mutations: [
-                { target: 'self', property: 'stage', expression: '0' },
-                {
-                    target: 'ref($to_stack_id)',
-                    property: 'quantity',
-                    expression: 'ref($to_stack_id).quantity + self.output_qty',
-                },
-            ],
-            returnExpression: 'self.output_qty',
-            invokePolicyJson: kitPolicyJson({
-                type: 'and',
-                rules: [
-                    { type: 'owner_of_self' },
-                    {
-                        type: 'condition',
-                        expression: [
-                            'self.stage >= self.max_stage',
-                            'ref($to_stack_id).item_id == self.output_item_id',
-                            ownerEqualsCaller('ref($to_stack_id).owner_user_id', kind),
-                        ].join(' && '),
-                    },
-                ],
-            }),
-            description: 'Harvest a grown crop: the stage reset and the yield grant commit atomically; regrows via the automation.',
-        });
-        automations.push({
-            name: names.growthAutomation,
-            functionName: names.growCropFn,
-            targetMode: 'type',
-            targetTypeName: names.cropType,
-            triggerType: 'schedule',
-            scheduleKind: 'interval',
-            intervalMs: crops.intervalMs ?? 60000,
-            maxTargets: 128,
-            selectorJson: JSON.stringify({
-                selfWhere: [{ key: 'stage', op: '<', value: 'self.max_stage' }],
-            }),
-            description: 'Advances growing crops one stage per tick.',
-        });
-    }
-    // --- Wave spawners -------------------------------------------------------------
-    if (options.waves) {
-        containerTypes.push({
-            typeName: names.spawnerType,
-            displayName: names.spawnerType,
-            instantiableBy: 'admin',
-            description: 'A wave counter the server advances; entity spawning stays host-side on the replication plane.',
-        });
-        propertyDefinitions.push({
-            containerTypeName: names.spawnerType,
-            key: 'wave',
-            valueType: 'int',
-            defaultValueJson: '0',
-            description: 'Current wave number.',
-        }, {
-            containerTypeName: names.spawnerType,
-            key: 'next_wave_size',
-            valueType: 'int',
-            defaultValueJson: '5',
-            description: 'Entities the host should spawn for the next wave.',
-        });
-        functions.push({
-            name: names.spawnWaveFn,
-            containerTypeName: names.spawnerType,
-            returnType: 'int',
-            mutations: [
-                { target: 'self', property: 'wave', expression: 'self.wave + 1' },
-                {
-                    target: 'self',
-                    property: 'next_wave_size',
-                    expression: `self.next_wave_size + ${options.waves.growth ?? 1}`,
-                },
-            ],
-            returnExpression: 'self.wave',
-            invokePolicyJson: automationOnly,
-            autonomousInvocable: true,
-            description: 'Server-driven wave advance (automation-only): bumps the counters the host reads to spawn entities.',
-        });
-        automations.push({
-            name: names.waveAutomation,
-            functionName: names.spawnWaveFn,
-            targetMode: 'type',
-            targetTypeName: names.spawnerType,
-            triggerType: 'schedule',
-            scheduleKind: 'interval',
-            intervalMs: options.waves.intervalMs ?? 60000,
-            maxTargets: 16,
-            description: 'Advances wave counters on schedule.',
-        });
-    }
-    if (!containerTypes.length) {
-        throw new Error('worldsimBlueprint has every feature disabled — nothing to build');
-    }
-    return {
-        name: names.worldStateType,
-        containerTypes,
-        propertyDefinitions,
-        functions,
-        automations,
-    };
-}

package/dist/kit/combat.d.ts

@@ -1,141 +0,0 @@
-import type { GameModelAPI } from '../domains/gameModel.js';
-import type { Scalars, SeedPropertyInput } from '../generated/graphql.js';
-import type { EngineDetector } from './engine.js';
-import { type KitInvokeResult } from './shared.js';
-/** Options for {@link CombatKit}. Must match the deployed combat blueprint. */
-export interface CombatKitOptions {
-    /** The `typePrefix` the combat blueprint was deployed with. */
-    typePrefix?: string;
-    /**
-     * The compute module whose referee serves `attack_mob` when the app runs
-     * an engine. Defaults to `'mob-engine'`.
-     */
-    engineModuleName?: string;
-}
-/** The verdict of a routed attack ({@link CombatKit.attackRouted}). */
-export interface KitRoutedAttack {
-    success: boolean;
-    /** The target's remaining health/hp after an accepted hit. */
-    health?: number;
-    killed?: boolean;
-    /** The denial reason (engine referee) or error message (model path). */
-    reason?: string;
-    /** Which authority resolved the attack. */
-    via: 'engine' | 'model';
-}
-/** A parsed view of one combatant. */
-export interface KitCombatant {
-    containerId: string;
-    displayName: string;
-    ownerUserId: string | null;
-    combatKey: string;
-    hp: number;
-    maxHp: number;
-    attack: number;
-    defense: number;
-    alive: boolean;
-}
-/** A parsed view of one status effect. */
-export interface KitStatusEffect {
-    containerId: string;
-    displayName: string;
-    ownerUserId: string | null;
-    effectId: string;
-    targetKey: string;
-    magnitude: number;
-    ticksLeft: number;
-}
-/**
- * Runtime helpers for the {@link combatBlueprint} conventions: spawn
- * combatants, attack (server-side damage formula + death flip), arm status
- * effects the tick automation applies over time, respawn, and route
- * competitive realtime attacks through a compute referee. `hostSynced`
- * remains a low-stakes/legacy fallback for persisting elected-host state;
- * it is not an anti-cheat boundary. Denials resolve with `success: false`.
- *
- * Obtained via `client.kit(appId).combat`.
- */
-export declare class CombatKit {
-    private readonly appId;
-    private readonly gameModel;
-    private readonly engines?;
-    private readonly names;
-    private readonly engineModuleName;
-    constructor(appId: Scalars['BigInt']['input'], gameModel: GameModelAPI, options?: CombatKitOptions, engines?: EngineDetector | undefined);
-    /**
-     * Route an attack through the strongest available authority: the compute
-     * referee (`attack_mob` on the mob engine — presence/range validated
-     * server-side) when the engine is deployed (capability-detected, cached),
-     * else today's model attack function. One call, both deployments.
-     *
-     * @param input.targetId - The target container (engine mob slot or model
-     *   combatant).
-     * @param input.attackerId - The caller's combatant container — required
-     *   for the model path, ignored by the engine referee (it referees by the
-     *   caller's live actor position).
-     * @param input.amount - Engine-path damage (clamped by the referee).
-     */
-    attackRouted(input: {
-        targetId: string;
-        attackerId?: string;
-        amount?: number;
-    }): Promise<KitRoutedAttack>;
-    /**
-     * Spawn a combatant with a unique `combat_key` (the status-effect join
-     * key) and the `owner_user_id` mirror.
-     */
-    spawnCombatant(input: {
-        ownerUserId: Scalars['BigInt']['input'];
-        displayName: string;
-        hp?: number;
-        maxHp?: number;
-        attack?: number;
-        defense?: number;
-        combatKey?: string;
-        sessionId?: string;
-        properties?: SeedPropertyInput[];
-    }): Promise<{
-        __typename?: "GmContainer";
-        containerId: string;
-        appId: string;
-        sessionId: string | null;
-        typeName: string;
-        displayName: string;
-        description: string | null;
-        ownerUserId: string | null;
-        metadataJson: string;
-    }>;
-    /** Read one combatant's state. */
-    state(combatantId: string): Promise<KitCombatant>;
-    /**
-     * Attack a target with your combatant. The damage formula and the death
-     * flip run server-side. Resolves with the target's remaining hp.
-     */
-    attack(attackerId: string, targetId: string): Promise<KitInvokeResult<number>>;
-    /**
-     * Arm a status effect against a target's `combat_key`: creates the
-     * caller's StatusEffect container (when `effectContainerId` is omitted)
-     * and invokes the gated apply function; the interval automation then
-     * ticks it server-side.
-     */
-    applyEffect(input: {
-        targetKey: string;
-        effectId: string;
-        magnitude: number;
-        ticks: number;
-        effectContainerId?: string;
-        sessionId?: string;
-    }): Promise<KitInvokeResult<number>>;
-    /** List the active status effects targeting a combat_key. */
-    effects(targetKey?: string): Promise<KitStatusEffect[]>;
-    /** Respawn your downed combatant at full hp. */
-    respawn(combatantId: string): Promise<KitInvokeResult<number>>;
-    /** Revive a downed combatant (blueprint deployed with `reviveGroup`). */
-    revive(combatantId: string): Promise<KitInvokeResult<number>>;
-    /**
-     * Persist host-simulated hp (blueprint deployed with `hostSynced: true`;
-     * `is_host` enforced server-side). Resolves with the clamped hp.
-     */
-    syncCombatant(combatantId: string, hp: number): Promise<KitInvokeResult<number>>;
-}
-//# sourceMappingURL=combat.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"combat.d.ts","sourceRoot":"","sources":["../../src/kit/combat.ts"],"names":[],"mappings":"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"}