@crowdedkingdoms/crowdyjs 8.0.0 → 8.1.0

package/dist/kit/blueprints.js

@@ -0,0 +1,480 @@
+/** Serialize a {@link KitInvokePolicy} tree to the wire `invokePolicyJson`. */
+export function kitPolicyJson(policy) {
+    return JSON.stringify(policy);
+}
+/** Convert `PascalCase`/`camelCase` to `snake_case` for derived names. */
+export function toSnakeCase(name) {
+    return name
+        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+        .replace(/[\s-]+/g, '_')
+        .toLowerCase();
+}
+/** 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 } = options;
+    const names = inventoryNames(typePrefix);
+    const ownerOnly = kitPolicyJson({ type: 'owner_of_self' });
+    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: 'member',
+                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' },
+            {
+                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: ownerOnly,
+                description: '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.',
+            },
+        ],
+    };
+}
+/** Compute the type/function names a lock blueprint (and its runtime helper) uses. */
+export function lockNames(objectTypeName = 'Lockable', keyTypeName) {
+    const snake = toSnakeCase(objectTypeName);
+    return {
+        objectType: objectTypeName,
+        keyType: keyTypeName ?? `${objectTypeName}Key`,
+        openFn: `open_${snake}`,
+        closeFn: `close_${snake}`,
+    };
+}
+function lockAuthorityRule(authority) {
+    switch (authority.kind) {
+        case 'owner':
+            return { type: 'owner_of_self' };
+        case 'key':
+            // Container ownership is not readable from expressions, so the key
+            // mirrors its owner into an `owner_user_id` property; the condition
+            // verifies both the match and the ownership server-side.
+            return {
+                type: 'condition',
+                expression: 'ref($key_id).key_id == self.required_key_id && ref($key_id).owner_user_id == $caller_user_id',
+            };
+        case 'gridPermission':
+            return {
+                type: 'grid_permission',
+                key: authority.key,
+                ...(authority.gridId !== undefined ? { gridId: authority.gridId } : {}),
+            };
+        case 'groupPermission':
+            return {
+                type: 'group_permission',
+                groupId: authority.groupId,
+                ...(authority.permission !== undefined
+                    ? { permission: authority.permission }
+                    : {}),
+            };
+        case 'custom':
+            return authority.rule;
+    }
+}
+/**
+ * Blueprint for a **lockable game object** (door, chest, gate, switch) whose
+ * `open`/`close` functions are gated by a configurable authority source:
+ * ownership, a key item the caller must hold, a runtime grid permission, a
+ * team/group permission, or any custom policy rule. Multiple authorities are
+ * OR'd, so "the owner, or anyone with the right key" is one blueprint.
+ *
+ * Runtime counterpart: `client.kit(appId).objects`.
+ */
+export function lockBlueprint(options) {
+    const authorities = Array.isArray(options.authority)
+        ? options.authority
+        : [options.authority];
+    if (authorities.length === 0) {
+        throw new Error('lockBlueprint requires at least one authority source');
+    }
+    const names = lockNames(options.objectTypeName, options.keyTypeName);
+    const usesKey = authorities.some((a) => a.kind === 'key');
+    const rules = authorities.map(lockAuthorityRule);
+    const policy = rules.length === 1 ? rules[0] : { type: 'or', rules };
+    const policyJson = kitPolicyJson(policy);
+    const parameters = usesKey
+        ? [{ name: 'key_id', valueType: 'container_ref', required: true }]
+        : [];
+    const containerTypes = [
+        {
+            typeName: names.objectType,
+            displayName: names.objectType,
+            instantiableBy: 'admin',
+            description: 'A lockable world object operated through gated functions.',
+        },
+    ];
+    const propertyDefinitions = [
+        {
+            containerTypeName: names.objectType,
+            key: 'is_open',
+            valueType: 'bool',
+            defaultValueJson: 'false',
+        },
+    ];
+    if (usesKey) {
+        propertyDefinitions.push({
+            containerTypeName: names.objectType,
+            key: 'required_key_id',
+            valueType: 'string',
+        });
+        containerTypes.push({
+            typeName: names.keyType,
+            displayName: names.keyType,
+            instantiableBy: 'admin',
+            description: 'A key item granting access to matching lockable objects.',
+        });
+        propertyDefinitions.push({ containerTypeName: names.keyType, key: 'key_id', valueType: 'string' }, {
+            containerTypeName: names.keyType,
+            key: 'owner_user_id',
+            valueType: 'int',
+        });
+    }
+    const openMutation = {
+        target: 'self',
+        property: 'is_open',
+        expression: 'true',
+    };
+    const closeMutation = {
+        target: 'self',
+        property: 'is_open',
+        expression: 'false',
+    };
+    return {
+        name: names.objectType,
+        containerTypes,
+        propertyDefinitions,
+        functions: [
+            {
+                name: names.openFn,
+                containerTypeName: names.objectType,
+                returnType: 'bool',
+                parameters,
+                mutations: [openMutation],
+                returnExpression: 'self.is_open',
+                invokePolicyJson: policyJson,
+                description: `Open a ${names.objectType}; the invoke policy decides who may.`,
+            },
+            {
+                name: names.closeFn,
+                containerTypeName: names.objectType,
+                returnType: 'bool',
+                parameters,
+                mutations: [closeMutation],
+                returnExpression: 'self.is_open',
+                invokePolicyJson: policyJson,
+                description: `Close a ${names.objectType}; same authority as opening.`,
+            },
+        ],
+    };
+}
+/** Compute the function/automation names an NPC behavior deploys under. */
+export function npcBehaviorFunctionName(behavior) {
+    return behavior.functionName ?? toSnakeCase(behavior.name);
+}
+/**
+ * Blueprint for an **NPC archetype**: an admin-instantiable container type
+ * holding the NPC's durable state, one `autonomousInvocable` model function
+ * per behavior (gated `is_automation` so players cannot puppet them), and the
+ * automations + event triggers that drive those behaviors on the server.
+ *
+ * Runtime counterpart: `client.kit(appId).npcs`.
+ */
+export function npcBlueprint(options) {
+    const typeName = options.typeName ?? 'Npc';
+    if (options.behaviors.length === 0) {
+        throw new Error('npcBlueprint requires at least one behavior');
+    }
+    const propertyDefinitions = [
+        {
+            containerTypeName: typeName,
+            key: 'role',
+            valueType: 'string',
+            defaultValueJson: '""',
+        },
+        { containerTypeName: typeName, key: 'x', valueType: 'float', defaultValueJson: '0' },
+        { containerTypeName: typeName, key: 'y', valueType: 'float', defaultValueJson: '0' },
+        { containerTypeName: typeName, key: 'z', valueType: 'float', defaultValueJson: '0' },
+        {
+            containerTypeName: typeName,
+            key: 'behavior_state',
+            valueType: 'string',
+            defaultValueJson: '"idle"',
+        },
+        {
+            containerTypeName: typeName,
+            key: 'health',
+            valueType: 'int',
+            defaultValueJson: '100',
+        },
+        ...(options.extraProperties ?? []).map((p) => ({
+            ...p,
+            containerTypeName: typeName,
+        })),
+    ];
+    const functions = [];
+    const automations = [];
+    const automationTriggers = [];
+    for (const behavior of options.behaviors) {
+        const functionName = npcBehaviorFunctionName(behavior);
+        functions.push({
+            name: functionName,
+            containerTypeName: typeName,
+            parameters: behavior.parameters,
+            mutations: behavior.mutations,
+            invokePolicyJson: kitPolicyJson({ type: 'is_automation' }),
+            autonomousInvocable: true,
+            description: `Server-driven NPC behavior for the '${behavior.name}' automation.`,
+        });
+        const selector = behavior.selector ??
+            (behavior.role !== undefined
+                ? { selfWhere: [{ key: 'role', op: '==', value: behavior.role }] }
+                : undefined);
+        const automation = {
+            name: behavior.name,
+            functionName,
+            targetMode: 'type',
+            targetTypeName: typeName,
+            maxTargets: behavior.maxTargets ?? 8,
+            ...(selector ? { selectorJson: JSON.stringify(selector) } : {}),
+            ...(behavior.params ? { paramsJson: JSON.stringify(behavior.params) } : {}),
+            ...(behavior.runAsUserId !== undefined
+                ? { runAsUserId: behavior.runAsUserId }
+                : {}),
+        };
+        if ('intervalMs' in behavior.trigger) {
+            automation.triggerType = 'schedule';
+            automation.scheduleKind = 'interval';
+            automation.intervalMs = behavior.trigger.intervalMs;
+        }
+        else if ('cronExpr' in behavior.trigger) {
+            automation.triggerType = 'schedule';
+            automation.scheduleKind = 'cron';
+            automation.cronExpr = behavior.trigger.cronExpr;
+        }
+        else {
+            automation.triggerType = 'event';
+            automationTriggers.push({
+                automationName: behavior.name,
+                onEvent: behavior.trigger.onEvent,
+                ...(behavior.trigger.functionName !== undefined
+                    ? { functionName: behavior.trigger.functionName }
+                    : {}),
+                ...(behavior.trigger.containerTypeName !== undefined
+                    ? { containerTypeName: behavior.trigger.containerTypeName }
+                    : {}),
+                ...(behavior.trigger.propertyKey !== undefined
+                    ? { propertyKey: behavior.trigger.propertyKey }
+                    : {}),
+                ...(behavior.trigger.debounceMs !== undefined
+                    ? { debounceMs: behavior.trigger.debounceMs }
+                    : {}),
+            });
+        }
+        automations.push(automation);
+    }
+    return {
+        name: typeName,
+        containerTypes: [
+            {
+                typeName,
+                displayName: typeName,
+                instantiableBy: 'admin',
+                description: 'A server-driven non-player character.',
+            },
+        ],
+        propertyDefinitions,
+        functions,
+        automations,
+        automationTriggers,
+    };
+}
+/**
+ * Merge blueprints into a single `gameModelSeed` payload plus the automation
+ * upserts, rejecting duplicate type, property, function, or automation names
+ * across blueprints (a duplicate almost always means two blueprints need
+ * distinct prefixes/type names).
+ */
+export function mergeBlueprints(appId, blueprints, options = {}) {
+    const containerTypes = [];
+    const propertyDefinitions = [];
+    const functions = [];
+    const containers = [];
+    const edges = [];
+    const automations = [];
+    const automationTriggers = [];
+    const seenTypes = new Map();
+    const seenProps = new Map();
+    const seenFunctions = new Map();
+    const seenAutomations = new Map();
+    const seenTempIds = new Map();
+    const claim = (seen, key, blueprintName, kind) => {
+        const existing = seen.get(key);
+        if (existing !== undefined) {
+            throw new Error(`Blueprint '${blueprintName}' redefines ${kind} '${key}' already defined by blueprint '${existing}'`);
+        }
+        seen.set(key, blueprintName);
+    };
+    for (const blueprint of blueprints) {
+        for (const type of blueprint.containerTypes ?? []) {
+            claim(seenTypes, type.typeName, blueprint.name, 'container type');
+            containerTypes.push(type);
+        }
+        for (const prop of blueprint.propertyDefinitions ?? []) {
+            claim(seenProps, `${prop.containerTypeName}.${prop.key}`, blueprint.name, 'property');
+            propertyDefinitions.push(prop);
+        }
+        for (const fn of blueprint.functions ?? []) {
+            claim(seenFunctions, fn.name, blueprint.name, 'function');
+            functions.push(fn);
+        }
+        for (const container of blueprint.containers ?? []) {
+            claim(seenTempIds, container.tempId, blueprint.name, 'container tempId');
+            containers.push(container);
+        }
+        edges.push(...(blueprint.edges ?? []));
+        for (const automation of blueprint.automations ?? []) {
+            claim(seenAutomations, automation.name, blueprint.name, 'automation');
+            automations.push({ ...automation, appId });
+        }
+        for (const trigger of blueprint.automationTriggers ?? []) {
+            automationTriggers.push({ ...trigger, appId });
+        }
+    }
+    const seedInput = {
+        appId,
+        ...(options.sessionId !== undefined ? { sessionId: options.sessionId } : {}),
+        ...(containerTypes.length ? { containerTypes } : {}),
+        ...(propertyDefinitions.length ? { propertyDefinitions } : {}),
+        ...(functions.length ? { functions } : {}),
+        ...(containers.length ? { containers } : {}),
+        ...(edges.length ? { edges } : {}),
+    };
+    return { seedInput, automations, automationTriggers };
+}

package/dist/kit/index.d.ts

@@ -0,0 +1,7 @@
+export { inventoryBlueprint, inventoryNames, kitPolicyJson, lockBlueprint, lockNames, mergeBlueprints, npcBehaviorFunctionName, npcBlueprint, toSnakeCase, type InventoryBlueprintOptions, type InventoryNames, type KitAutomationSpec, type KitAutomationTriggerSpec, type KitBlueprint, type KitInvokePolicy, type LockAuthority, type LockBlueprintOptions, type LockNames, type MergedBlueprints, type NpcBehaviorSpec, type NpcBehaviorTrigger, type NpcBlueprintOptions, } from './blueprints.js';
+export { GameKitClient, type GameKitOptions, type KitDeployResult, } from './kit.js';
+export { InventoryKit, type InventoryKitOptions, type KitItemStack } from './inventory.js';
+export { ObjectsKit, type ObjectsKitOptions } from './objects.js';
+export { NpcsKit, type NpcsKitOptions, type KitNpc } from './npcs.js';
+export { kitInvoke, toKitInvokeResult, type KitInvokeResult, type RawInvokeResult, } from './shared.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/kit/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,cAAc,EACd,aAAa,EACb,aAAa,EACb,SAAS,EACT,eAAe,EACf,uBAAuB,EACvB,YAAY,EACZ,WAAW,EACX,KAAK,yBAAyB,EAC9B,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,wBAAwB,EAC7B,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,oBAAoB,EACzB,KAAK,SAAS,EACd,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,GACzB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,aAAa,EACb,KAAK,cAAc,EACnB,KAAK,eAAe,GACrB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,YAAY,EAAE,KAAK,mBAAmB,EAAE,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC3F,OAAO,EAAE,UAAU,EAAE,KAAK,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAClE,OAAO,EAAE,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,MAAM,EAAE,MAAM,WAAW,CAAC;AACtE,OAAO,EACL,SAAS,EACT,iBAAiB,EACjB,KAAK,eAAe,EACpB,KAAK,eAAe,GACrB,MAAM,aAAa,CAAC"}

package/dist/kit/index.js

@@ -0,0 +1,6 @@
+export { inventoryBlueprint, inventoryNames, kitPolicyJson, lockBlueprint, lockNames, mergeBlueprints, npcBehaviorFunctionName, npcBlueprint, toSnakeCase, } from './blueprints.js';
+export { GameKitClient, } from './kit.js';
+export { InventoryKit } from './inventory.js';
+export { ObjectsKit } from './objects.js';
+export { NpcsKit } from './npcs.js';
+export { kitInvoke, toKitInvokeResult, } from './shared.js';

package/dist/kit/inventory.d.ts

@@ -0,0 +1,111 @@
+import type { GameModelAPI } from '../domains/gameModel.js';
+import type { Scalars } from '../generated/graphql.js';
+import { type KitInvokeResult } from './shared.js';
+/** Options for {@link InventoryKit}. Must match the deployed blueprint's options. */
+export interface InventoryKitOptions {
+    /** The `typePrefix` the inventory blueprint was deployed with. */
+    typePrefix?: string;
+}
+/** A parsed view of one item stack. */
+export interface KitItemStack {
+    containerId: string;
+    displayName: string;
+    ownerUserId: string | null;
+    itemId: string;
+    quantity: number;
+    slot: number;
+}
+/**
+ * Runtime helpers for the {@link inventoryBlueprint} conventions: find or
+ * create the player's inventory, list stacks, and mutate them through the
+ * owner-gated model functions. All state lives server-side; every mutation is
+ * authority-checked and atomic.
+ *
+ * Obtained via `client.kit(appId).inventory`.
+ */
+export declare class InventoryKit {
+    private readonly appId;
+    private readonly gameModel;
+    private readonly names;
+    constructor(appId: Scalars['BigInt']['input'], gameModel: GameModelAPI, options?: InventoryKitOptions);
+    /**
+     * Find the caller's inventory container, creating it when absent. The
+     * server assigns ownership to the caller (the type is member-instantiable
+     * and `ownerUserId` is omitted on create).
+     *
+     * @param ownerUserId - The calling player's user id (a decimal string, e.g.
+     *   from `client.users.me()`), used to recognize an existing inventory.
+     */
+    ensure(ownerUserId: Scalars['BigInt']['input'], options?: {
+        displayName?: string;
+        sessionId?: string;
+    }): Promise<{
+        __typename?: "GmContainer";
+        containerId: string;
+        appId: string;
+        sessionId: string | null;
+        typeName: string;
+        displayName: string;
+        description: string | null;
+        ownerUserId: string | null;
+        metadataJson: string;
+    }>;
+    /**
+     * List a player's item stacks with parsed properties (`itemId`, `quantity`,
+     * `slot`). Fetches each stack's visible state in parallel.
+     */
+    stacks(ownerUserId: Scalars['BigInt']['input']): Promise<KitItemStack[]>;
+    /**
+     * Create a new stack owned by the caller (server-assigned ownership).
+     * Use {@link grant} afterwards for authority-checked increments; the initial
+     * quantity here is a seed value on a container the caller owns anyway.
+     */
+    createStack(input: {
+        itemId: string;
+        quantity?: number;
+        slot?: number;
+        displayName?: string;
+        sessionId?: string;
+    }): Promise<{
+        __typename?: "GmContainer";
+        containerId: string;
+        appId: string;
+        sessionId: string | null;
+        typeName: string;
+        displayName: string;
+        description: string | null;
+        ownerUserId: string | null;
+        metadataJson: string;
+    }>;
+    /** Add items to a stack the caller owns. Resolves with the new quantity. */
+    grant(stackId: string, amount: number): Promise<KitInvokeResult<number>>;
+    /**
+     * Spend items from a stack the caller owns. The server refuses to overdraw
+     * (`success: false`, nothing written). Resolves with the new quantity.
+     */
+    consume(stackId: string, amount: number): Promise<KitInvokeResult<number>>;
+    /** Move a stack to another slot. Resolves with the new (clamped) slot. */
+    move(stackId: string, toSlot: number): Promise<KitInvokeResult<number>>;
+    /**
+     * Atomically move items between two stacks of the same item type — both
+     * writes commit or neither does. The caller must own the source stack.
+     * Resolves with the source stack's remaining quantity.
+     */
+    transfer(fromStackId: string, toStackId: string, amount: number): Promise<KitInvokeResult<number>>;
+    /**
+     * Record that a stack belongs to an inventory with an
+     * `inventory_contains` edge, so {@link contents} can read the whole bag in
+     * one traversal.
+     */
+    linkStack(inventoryId: string, stackId: string): Promise<{
+        __typename?: "GmEdge";
+        edgeId: string;
+        fromContainerId: string;
+        toContainerId: string;
+        relationshipType: string;
+        weight: number | null;
+    }>;
+    /** Read every stack linked to an inventory (via `inventory_contains` edges). */
+    contents(inventoryId: string): Promise<KitItemStack[]>;
+}
+//# sourceMappingURL=inventory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inventory.d.ts","sourceRoot":"","sources":["../../src/kit/inventory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAEvD,OAAO,EAGL,KAAK,eAAe,EACrB,MAAM,aAAa,CAAC;AAErB,qFAAqF;AACrF,MAAM,WAAW,mBAAmB;IAClC,kEAAkE;IAClE,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,uCAAuC;AACvC,MAAM,WAAW,YAAY;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;GAOG;AACH,qBAAa,YAAY;IAIrB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAJ5B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAiB;gBAGpB,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,EACjC,SAAS,EAAE,YAAY,EACxC,OAAO,GAAE,mBAAwB;IAKnC;;;;;;;OAOG;IACG,MAAM,CACV,WAAW,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,EACvC,OAAO,GAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAO;;;;;;;;;;;IAmB5D;;;OAGG;IACG,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IA2B9E;;;;OAIG;IACG,WAAW,CAAC,KAAK,EAAE;QACvB,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB;;;;;;;;;;;IAcD,4EAA4E;IACtE,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;IAS9E;;;OAGG;IACG,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;IAShF,0EAA0E;IACpE,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;IAS7E;;;;OAIG;IACG,QAAQ,CACZ,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;IASnC;;;;OAIG;IACG,SAAS,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;;;;;;;;IASpD,gFAAgF;IAC1E,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;CA4B7D"}