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

package/dist/kit/notifications.js

@@ -1,67 +0,0 @@
-/**
- * Builders for a model function's `notifications`, so the non-staleable shape is the easy
- * one to reach for.
- *
- * WHY THESE EXIST AT ALL, given the input is three lines of JSON. A channel notification
- * can name its target two ways, and only one of them survives the app being recreated or
- * moved between organizations. Membership is scoped to the app, so a function naming a
- * channel that belongs to a DIFFERENT app produces a notification that is built, signed,
- * sent to every server and then dropped for want of a recipient -- while the invoke
- * succeeds and the run records success, because emission is best-effort and never fails a
- * function. The only symptom is silence.
- *
- * That is not hypothetical: it is what a copied game model does, and the server now reports
- * it as the `notification_channel_foreign` lint error. A NAME is resolved per-invocation
- * against the app that is running, so it cannot go stale the way an id copied between apps
- * does. `sessionChannel` is the shape to prefer.
- */
-/**
- * Notify every client in the app's default session channel.
- *
- * `$session_channel_name` is injected by the server from the app the function is RUNNING
- * in, so this expression is correct in any app that ever holds this definition -- which is
- * the whole point. It is also the channel every SDK client joins on connect, so this is
- * "tell everyone playing" with nothing to configure and nothing to keep in sync.
- */
-export function sessionChannelNotification(payloadExpression) {
-    return {
-        kind: 'channel',
-        args: [
-            { name: 'channel_name', expression: '$session_channel_name' },
-            { name: 'payload', expression: payloadExpression },
-        ],
-    };
-}
-/**
- * Notify a channel named by NAME rather than by id.
- *
- * Use this when the channel is not the session channel but is still derivable -- a lobby
- * per app, say, as `concat("lobby-", $app_id)`. Same property as above: resolved against
- * the running app, so a copied model addresses its new home.
- */
-export function namedChannelNotification(channelNameExpression, payloadExpression) {
-    return {
-        kind: 'channel',
-        args: [
-            { name: 'channel_name', expression: channelNameExpression },
-            { name: 'payload', expression: payloadExpression },
-        ],
-    };
-}
-/**
- * Notify a channel named by id.
- *
- * Correct when the id is READ FROM MODEL STATE -- `self.channel_id` on a container that
- * owns its own channel is the shape the matches blueprint uses, and it is app-portable
- * because the property travels with the row. A LITERAL id is the one to avoid, and the
- * server's `notification_channel_foreign` lint error exists to catch it.
- */
-export function channelIdNotification(channelIdExpression, payloadExpression) {
-    return {
-        kind: 'channel',
-        args: [
-            { name: 'channel_id', expression: channelIdExpression },
-            { name: 'payload', expression: payloadExpression },
-        ],
-    };
-}

package/dist/kit/npcs.d.ts

@@ -1,226 +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 { EnginePose } from './wire.js';
-/** Options for {@link NpcsKit}. Must match the deployed NPC blueprint. */
-export interface NpcsKitOptions {
-    /** The `typeName` the NPC blueprint was deployed with. Defaults to `'Npc'`. */
-    typeName?: string;
-    /**
-     * The compute module driving NPC movement when the app runs an engine
-     * (smooth FLAG_NPC actor emits instead of property nudges). Defaults to
-     * `'npc-engine'`.
-     */
-    moduleName?: string;
-}
-/**
- * The minimal shape of a live actor entry {@link overlayLivePoses} reads —
- * matches the world-session `RemoteActor<EnginePose>` without importing it.
- */
-export interface LiveNpcPose {
-    uuid: string;
-    state: Pick<EnginePose, 'x' | 'y' | 'z'>;
-    receivedAt: number;
-}
-/** A parsed view of one live NPC. */
-export interface KitNpc {
-    containerId: string;
-    displayName: string;
-    role: string;
-    x: number;
-    y: number;
-    z: number;
-    behaviorState: string;
-    health: number;
-    /** All visible properties, including any extras your blueprint added. */
-    properties: Record<string, unknown>;
-}
-/**
- * Runtime helpers for the {@link npcBlueprint} conventions: spawn NPC
- * instances, read their server-driven state, and manage/monitor the
- * automations behind them. Behaviors run in the API server — clients only
- * re-read state (or listen for model-driven notifications) and render.
- *
- * Spawning and the automation management/monitoring calls are studio/admin
- * operations (`manage_apps`); reads are player-safe.
- *
- * Obtained via `client.kit(appId).npcs`.
- */
-export declare class NpcsKit {
-    private readonly appId;
-    private readonly gameModel;
-    private readonly engines?;
-    private readonly typeName;
-    private readonly moduleName;
-    constructor(appId: Scalars['BigInt']['input'], gameModel: GameModelAPI, options?: NpcsKitOptions, engines?: EngineDetector | undefined);
-    /**
-     * Is an NPC compute engine deployed + enabled (cached per session)? When
-     * true, NPCs stream smooth FLAG_NPC actor poses — overlay them with
-     * {@link overlayLivePoses}. When false (model-only deployment), the polled
-     * container positions are all there is, exactly as before.
-     */
-    engineAvailable(): Promise<boolean>;
-    /**
-     * Overlay live engine-driven poses onto a polled NPC snapshot (the
-     * generalized BWF `NpcService.withLivePoses` pattern): each NPC whose
-     * `actor_uuid` has a fresh pose in the npcs actor lane gets its position
-     * replaced; the rest keep their durable container position, so NPCs stand
-     * at their last synced spot instead of disappearing.
-     *
-     * @param npcs - The polled snapshot (from {@link list}).
-     * @param lane - The live actors, e.g. `session.actors.lane('npcs').list()`.
-     */
-    overlayLivePoses(npcs: KitNpc[], lane: LiveNpcPose[]): KitNpc[];
-    /** Spawn a live NPC instance (admin — the type is admin-instantiable). */
-    spawn(input: {
-        displayName: string;
-        role?: string;
-        position?: {
-            x: number;
-            y: number;
-            z: number;
-        };
-        properties?: SeedPropertyInput[];
-        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 live NPCs with parsed state, optionally filtered by `role`. Fetches
-     * each NPC's visible properties in parallel — fine for the bounded NPC
-     * populations automations are designed around.
-     */
-    list(options?: {
-        role?: string;
-        sessionId?: string;
-    }): Promise<KitNpc[]>;
-    /** Read one NPC's current server-side state. */
-    state(npcId: string): Promise<KitNpc>;
-    /** Run one of the NPC automations immediately (admin; useful for testing). */
-    runNow(automationName: string): Promise<{
-        __typename?: "GmAutomationRun";
-        runId: string;
-        appId: string;
-        flowId: string | null;
-        automationId: string | null;
-        automationName: string;
-        triggerSource: string;
-        triggerId: string | null;
-        parentRunId: string | null;
-        cascadeDepth: number;
-        startedAt: string;
-        finishedAt: string | null;
-        durationUs: number;
-        targets: number;
-        invocations: number;
-        mutations: number;
-        fnCalls: number;
-        gasUsed: number;
-        success: boolean;
-        errorMessage: string | null;
-        circuitAction: string | null;
-        computeUnits: number;
-    }>;
-    /**
-     * Pause or resume an NPC automation (admin). Re-enabling also resets a
-     * tripped failure circuit.
-     */
-    setEnabled(automationName: string, enabled: boolean): Promise<{
-        __typename?: "GmAutomation";
-        automationId: string;
-        appId: string;
-        name: string;
-        description: string | null;
-        enabled: boolean;
-        actionKind: string;
-        functionName: string | null;
-        computeModuleName: string | null;
-        computeExport: string | null;
-        targetMode: string;
-        selfContainerId: string | null;
-        targetTypeName: string | null;
-        sessionId: string | null;
-        paramsJson: string;
-        selectorJson: string | null;
-        runAsUserId: string | null;
-        triggerType: string;
-        scheduleKind: string | null;
-        intervalMs: number | null;
-        cronExpr: string | null;
-        maxTargets: number;
-        maxFnDepth: number | null;
-        gasLimit: number | null;
-        runTimeoutMs: number | null;
-        maxRunsPerMinute: number;
-        failureThreshold: number;
-        cooldownMs: number;
-        circuitState: string;
-        consecutiveFailures: number;
-        pausedUntil: string | null;
-        lastError: string | null;
-        lastRunAt: string | null;
-        nextRunAt: string | null;
-    }>;
-    /** Aggregate "what are my NPCs doing" stats over a recent window (admin). */
-    stats(windowMinutes?: number): Promise<{
-        __typename?: "GmAutomationStats";
-        windowMinutes: number;
-        totalRuns: number;
-        failedRuns: number;
-        failureRatePct: number;
-        runsPerMinute: number;
-        totalInvocations: number;
-        totalMutations: number;
-        totalComputeUnits: number;
-        avgDurationUs: number;
-        byAutomation: Array<{
-            __typename?: "GmAutomationStat";
-            automationName: string;
-            runs: number;
-            failures: number;
-            invocations: number;
-            computeUnits: number;
-            avgDurationUs: number;
-            circuitState: string;
-        }>;
-    }>;
-    /** Recent automation run history, newest first (admin). */
-    runs(options?: {
-        automationName?: string;
-        success?: boolean;
-        limit?: number;
-    }): Promise<{
-        __typename?: "GmAutomationRun";
-        runId: string;
-        appId: string;
-        flowId: string | null;
-        automationId: string | null;
-        automationName: string;
-        triggerSource: string;
-        triggerId: string | null;
-        parentRunId: string | null;
-        cascadeDepth: number;
-        startedAt: string;
-        finishedAt: string | null;
-        durationUs: number;
-        targets: number;
-        invocations: number;
-        mutations: number;
-        fnCalls: number;
-        gasUsed: number;
-        success: boolean;
-        errorMessage: string | null;
-        circuitAction: string | null;
-        computeUnits: number;
-    }[]>;
-    private toNpc;
-}
-//# sourceMappingURL=npcs.d.ts.map

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

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

package/dist/kit/npcs.js

@@ -1,141 +0,0 @@
-import { kitContainerProperties } from './shared.js';
-/**
- * Runtime helpers for the {@link npcBlueprint} conventions: spawn NPC
- * instances, read their server-driven state, and manage/monitor the
- * automations behind them. Behaviors run in the API server — clients only
- * re-read state (or listen for model-driven notifications) and render.
- *
- * Spawning and the automation management/monitoring calls are studio/admin
- * operations (`manage_apps`); reads are player-safe.
- *
- * Obtained via `client.kit(appId).npcs`.
- */
-export class NpcsKit {
-    constructor(appId, gameModel, options = {}, engines) {
-        this.appId = appId;
-        this.gameModel = gameModel;
-        this.engines = engines;
-        this.typeName = options.typeName ?? 'Npc';
-        this.moduleName = options.moduleName ?? 'npc-engine';
-    }
-    /**
-     * Is an NPC compute engine deployed + enabled (cached per session)? When
-     * true, NPCs stream smooth FLAG_NPC actor poses — overlay them with
-     * {@link overlayLivePoses}. When false (model-only deployment), the polled
-     * container positions are all there is, exactly as before.
-     */
-    engineAvailable() {
-        if (!this.engines)
-            return Promise.resolve(false);
-        return this.engines.has(this.moduleName);
-    }
-    /**
-     * Overlay live engine-driven poses onto a polled NPC snapshot (the
-     * generalized BWF `NpcService.withLivePoses` pattern): each NPC whose
-     * `actor_uuid` has a fresh pose in the npcs actor lane gets its position
-     * replaced; the rest keep their durable container position, so NPCs stand
-     * at their last synced spot instead of disappearing.
-     *
-     * @param npcs - The polled snapshot (from {@link list}).
-     * @param lane - The live actors, e.g. `session.actors.lane('npcs').list()`.
-     */
-    overlayLivePoses(npcs, lane) {
-        if (lane.length === 0)
-            return npcs;
-        const poses = new Map(lane.map((actor) => [actor.uuid, actor]));
-        return npcs.map((npc) => {
-            const uuid = String(npc.properties.actor_uuid ?? '');
-            const live = uuid ? poses.get(uuid) : undefined;
-            if (!live)
-                return npc;
-            return { ...npc, x: live.state.x, y: live.state.y, z: live.state.z };
-        });
-    }
-    /** Spawn a live NPC instance (admin — the type is admin-instantiable). */
-    async spawn(input) {
-        const properties = [
-            ...(input.role !== undefined
-                ? [{ key: 'role', valueType: 'string', valueJson: JSON.stringify(input.role) }]
-                : []),
-            ...(input.position
-                ? [
-                    { key: 'x', valueType: 'float', valueJson: String(input.position.x) },
-                    { key: 'y', valueType: 'float', valueJson: String(input.position.y) },
-                    { key: 'z', valueType: 'float', valueJson: String(input.position.z) },
-                ]
-                : []),
-            ...(input.properties ?? []),
-        ];
-        return this.gameModel.createContainer({
-            appId: this.appId,
-            typeName: this.typeName,
-            displayName: input.displayName,
-            ...(input.sessionId !== undefined ? { sessionId: input.sessionId } : {}),
-            ...(properties.length ? { properties } : {}),
-        });
-    }
-    /**
-     * List live NPCs with parsed state, optionally filtered by `role`. Fetches
-     * each NPC's visible properties in parallel — fine for the bounded NPC
-     * populations automations are designed around.
-     */
-    async list(options = {}) {
-        const containers = await this.gameModel.containers({
-            appId: this.appId,
-            typeName: this.typeName,
-            ...(options.sessionId !== undefined ? { sessionId: options.sessionId } : {}),
-        });
-        const npcs = await Promise.all(containers.map((c) => this.toNpc(c.containerId, c.displayName)));
-        return options.role !== undefined
-            ? npcs.filter((n) => n.role === options.role)
-            : npcs;
-    }
-    /** Read one NPC's current server-side state. */
-    async state(npcId) {
-        const container = await this.gameModel.container({
-            appId: this.appId,
-            containerId: npcId,
-        });
-        return this.toNpc(container.containerId, container.displayName);
-    }
-    /** Run one of the NPC automations immediately (admin; useful for testing). */
-    async runNow(automationName) {
-        return this.gameModel.runAutomation({ appId: this.appId, name: automationName });
-    }
-    /**
-     * Pause or resume an NPC automation (admin). Re-enabling also resets a
-     * tripped failure circuit.
-     */
-    async setEnabled(automationName, enabled) {
-        return this.gameModel.setAutomationEnabled({
-            appId: this.appId,
-            name: automationName,
-            enabled,
-        });
-    }
-    /** Aggregate "what are my NPCs doing" stats over a recent window (admin). */
-    async stats(windowMinutes) {
-        return this.gameModel.automationStats({
-            appId: this.appId,
-            ...(windowMinutes !== undefined ? { windowMinutes } : {}),
-        });
-    }
-    /** Recent automation run history, newest first (admin). */
-    async runs(options = {}) {
-        return this.gameModel.automationRuns({ appId: this.appId, ...options });
-    }
-    async toNpc(containerId, displayName) {
-        const props = await kitContainerProperties(this.gameModel, String(this.appId), containerId);
-        return {
-            containerId,
-            displayName,
-            role: String(props.role ?? ''),
-            x: Number(props.x ?? 0),
-            y: Number(props.y ?? 0),
-            z: Number(props.z ?? 0),
-            behaviorState: String(props.behavior_state ?? ''),
-            health: Number(props.health ?? 0),
-            properties: props,
-        };
-    }
-}

package/dist/kit/objects.d.ts

@@ -1,116 +0,0 @@
-import type { GameModelAPI } from '../domains/gameModel.js';
-import type { Scalars, SeedPropertyInput } from '../generated/graphql.js';
-import { type KitInvokeResult } from './shared.js';
-/** Options for {@link ObjectsKit}. Must match the deployed lock blueprint. */
-export interface ObjectsKitOptions {
-    /** The `objectTypeName` the lock blueprint was deployed with. Defaults to `'Lockable'`. */
-    objectTypeName?: string;
-    /** The `keyTypeName` the lock blueprint was deployed with. */
-    keyTypeName?: string;
-}
-/**
- * Runtime helpers for the {@link lockBlueprint} conventions: instantiate
- * lockable world objects, grant key items, and operate the objects through
- * their authority-gated `open`/`close` functions. Authorization is decided
- * entirely server-side; a denied attempt resolves with `success: false`.
- *
- * Obtained via `client.kit(appId).objects` (or `client.kit(appId)
- * .objectsFor('Door')` for a non-default type name).
- */
-export declare class ObjectsKit {
-    private readonly appId;
-    private readonly gameModel;
-    private readonly names;
-    constructor(appId: Scalars['BigInt']['input'], gameModel: GameModelAPI, options?: ObjectsKitOptions);
-    /**
-     * Instantiate a lockable object (admin/studio call — the type is
-     * admin-instantiable). For key-gated objects set `requiredKeyId` to the key
-     * id that opens it; for owner-gated objects set `ownerUserId`; for
-     * chunk-permission-gated objects set `chunk` to where the object stands
-     * (feeds the `has_chunk_permission` policy).
-     */
-    create(input: {
-        displayName: string;
-        requiredKeyId?: string;
-        ownerUserId?: Scalars['BigInt']['input'];
-        /** The chunk the object occupies (chunkPermission authority). */
-        chunk?: {
-            x: number;
-            y: number;
-            z: number;
-        };
-        properties?: SeedPropertyInput[];
-        sessionId?: string;
-    }): Promise<{
-        __typename?: "GmContainer";
-        containerId: string;
-        appId: string;
-        sessionId: string | null;
-        typeName: string;
-        displayName: string;
-        description: string | null;
-        ownerUserId: string | null;
-        metadataJson: string;
-    }>;
-    /**
-     * Grant a player a key item (admin/studio call). Creates a key container
-     * owned by the player, with the owner mirrored into the `owner_user_id`
-     * property that the key condition policy reads.
-     */
-    grantKey(input: {
-        keyId: string;
-        toUserId: Scalars['BigInt']['input'];
-        displayName?: string;
-    }): Promise<{
-        __typename?: "GmContainer";
-        containerId: string;
-        appId: string;
-        sessionId: string | null;
-        typeName: string;
-        displayName: string;
-        description: string | null;
-        ownerUserId: string | null;
-        metadataJson: string;
-    }>;
-    /** List the key items a player holds. */
-    keysOf(userId: Scalars['BigInt']['input']): Promise<{
-        __typename?: "GmContainer";
-        containerId: string;
-        appId: string;
-        sessionId: string | null;
-        typeName: string;
-        displayName: string;
-        description: string | null;
-        ownerUserId: string | null;
-        metadataJson: string;
-    }[]>;
-    /**
-     * Try to open an object. Pass `keyId` (the **container id** of a key the
-     * caller holds) when the object is key-gated; owner/grid/group authorities
-     * need no params. A denial is not an exception — check `success`.
-     */
-    open(objectId: string, options?: {
-        keyId?: string;
-    }): Promise<KitInvokeResult<boolean>>;
-    /** Try to close an object; same authority as {@link open}. */
-    close(objectId: string, options?: {
-        keyId?: string;
-    }): Promise<KitInvokeResult<boolean>>;
-    /** Read whether an object is currently open. */
-    isOpen(objectId: string): Promise<boolean>;
-    /** List all objects of this lockable type. */
-    list(options?: {
-        sessionId?: string;
-    }): Promise<{
-        __typename?: "GmContainer";
-        containerId: string;
-        appId: string;
-        sessionId: string | null;
-        typeName: string;
-        displayName: string;
-        description: string | null;
-        ownerUserId: string | null;
-        metadataJson: string;
-    }[]>;
-}
-//# sourceMappingURL=objects.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"objects.d.ts","sourceRoot":"","sources":["../../src/kit/objects.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAE1E,OAAO,EAGL,KAAK,eAAe,EACrB,MAAM,aAAa,CAAC;AAErB,8EAA8E;AAC9E,MAAM,WAAW,iBAAiB;IAChC,2FAA2F;IAC3F,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,8DAA8D;IAC9D,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;GAQG;AACH,qBAAa,UAAU;IAInB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAJ5B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAY;gBAGf,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,EACjC,SAAS,EAAE,YAAY,EACxC,OAAO,GAAE,iBAAsB;IAKjC;;;;;;OAMG;IACG,MAAM,CAAC,KAAK,EAAE;QAClB,WAAW,EAAE,MAAM,CAAC;QACpB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,WAAW,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,CAAC;QACzC,iEAAiE;QACjE,KAAK,CAAC,EAAE;YAAE,CAAC,EAAE,MAAM,CAAC;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC;QAC5C,UAAU,CAAC,EAAE,iBAAiB,EAAE,CAAC;QACjC,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB;;;;;;;;;;;IA+BD;;;;OAIG;IACG,QAAQ,CAAC,KAAK,EAAE;QACpB,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,CAAC;QACrC,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB;;;;;;;;;;;IAiBD,yCAAyC;IACnC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC;;;;;;;;;;;IAU/C;;;;OAIG;IACG,IAAI,CACR,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAO,GAC/B,OAAO,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;IASpC,8DAA8D;IACxD,KAAK,CACT,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAO,GAC/B,OAAO,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;IASpC,gDAAgD;IAC1C,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAShD,8CAA8C;IACxC,IAAI,CAAC,OAAO,GAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAO;;;;;;;;;;;CAOhD"}

package/dist/kit/objects.js

@@ -1,119 +0,0 @@
-import { lockNames } from './blueprints/index.js';
-import { kitContainerProperties, kitInvoke, } from './shared.js';
-/**
- * Runtime helpers for the {@link lockBlueprint} conventions: instantiate
- * lockable world objects, grant key items, and operate the objects through
- * their authority-gated `open`/`close` functions. Authorization is decided
- * entirely server-side; a denied attempt resolves with `success: false`.
- *
- * Obtained via `client.kit(appId).objects` (or `client.kit(appId)
- * .objectsFor('Door')` for a non-default type name).
- */
-export class ObjectsKit {
-    constructor(appId, gameModel, options = {}) {
-        this.appId = appId;
-        this.gameModel = gameModel;
-        this.names = lockNames(options.objectTypeName, options.keyTypeName);
-    }
-    /**
-     * Instantiate a lockable object (admin/studio call — the type is
-     * admin-instantiable). For key-gated objects set `requiredKeyId` to the key
-     * id that opens it; for owner-gated objects set `ownerUserId`; for
-     * chunk-permission-gated objects set `chunk` to where the object stands
-     * (feeds the `has_chunk_permission` policy).
-     */
-    async create(input) {
-        const properties = [
-            { key: 'is_open', valueType: 'bool', valueJson: 'false' },
-            ...(input.requiredKeyId !== undefined
-                ? [
-                    {
-                        key: 'required_key_id',
-                        valueType: 'string',
-                        valueJson: JSON.stringify(input.requiredKeyId),
-                    },
-                ]
-                : []),
-            ...(input.chunk
-                ? [
-                    { key: 'cx', valueType: 'int', valueJson: String(input.chunk.x) },
-                    { key: 'cy', valueType: 'int', valueJson: String(input.chunk.y) },
-                    { key: 'cz', valueType: 'int', valueJson: String(input.chunk.z) },
-                ]
-                : []),
-            ...(input.properties ?? []),
-        ];
-        return this.gameModel.createContainer({
-            appId: this.appId,
-            typeName: this.names.objectType,
-            displayName: input.displayName,
-            ...(input.ownerUserId !== undefined ? { ownerUserId: input.ownerUserId } : {}),
-            ...(input.sessionId !== undefined ? { sessionId: input.sessionId } : {}),
-            properties,
-        });
-    }
-    /**
-     * Grant a player a key item (admin/studio call). Creates a key container
-     * owned by the player, with the owner mirrored into the `owner_user_id`
-     * property that the key condition policy reads.
-     */
-    async grantKey(input) {
-        return this.gameModel.createContainer({
-            appId: this.appId,
-            typeName: this.names.keyType,
-            displayName: input.displayName ?? `Key ${input.keyId}`,
-            ownerUserId: input.toUserId,
-            properties: [
-                { key: 'key_id', valueType: 'string', valueJson: JSON.stringify(input.keyId) },
-                {
-                    key: 'owner_user_id',
-                    valueType: 'int',
-                    valueJson: String(input.toUserId),
-                },
-            ],
-        });
-    }
-    /** List the key items a player holds. */
-    async keysOf(userId) {
-        const containers = await this.gameModel.containers({
-            appId: this.appId,
-            typeName: this.names.keyType,
-        });
-        return containers.filter((c) => c.ownerUserId != null && String(c.ownerUserId) === String(userId));
-    }
-    /**
-     * Try to open an object. Pass `keyId` (the **container id** of a key the
-     * caller holds) when the object is key-gated; owner/grid/group authorities
-     * need no params. A denial is not an exception — check `success`.
-     */
-    async open(objectId, options = {}) {
-        return kitInvoke(this.gameModel, {
-            appId: String(this.appId),
-            functionName: this.names.openFn,
-            selfContainerId: objectId,
-            params: options.keyId !== undefined ? { key_id: options.keyId } : {},
-        });
-    }
-    /** Try to close an object; same authority as {@link open}. */
-    async close(objectId, options = {}) {
-        return kitInvoke(this.gameModel, {
-            appId: String(this.appId),
-            functionName: this.names.closeFn,
-            selfContainerId: objectId,
-            params: options.keyId !== undefined ? { key_id: options.keyId } : {},
-        });
-    }
-    /** Read whether an object is currently open. */
-    async isOpen(objectId) {
-        const props = await kitContainerProperties(this.gameModel, String(this.appId), objectId);
-        return props.is_open === true;
-    }
-    /** List all objects of this lockable type. */
-    async list(options = {}) {
-        return this.gameModel.containers({
-            appId: this.appId,
-            typeName: this.names.objectType,
-            ...(options.sessionId !== undefined ? { sessionId: options.sessionId } : {}),
-        });
-    }
-}