unreal-engine-mcp-server 0.6.0-beta-e → 0.6.0

package/dist/tools/catalog/capabilities/record-folding.js

@@ -1,136 +0,0 @@
-import { readField } from './hashing.js';
-import { isRecord } from '../../../utils/validation/type-guards.js';
-export function verifyFolding(record, ctx) {
-    const legacyIds = readField(record, 'legacyIds');
-    if (!Array.isArray(legacyIds))
-        return;
-    const schemas = readField(record, 'schemas');
-    const input = isRecord(schemas) ? readField(schemas, 'input') : undefined;
-    const properties = isRecord(input) && isRecord(input.properties) ? input.properties : {};
-    const required = isRecord(input) && Array.isArray(input.required) ? input.required : [];
-    const enumOf = (name) => {
-        const property = readField(properties, name);
-        return isRecord(property) && Array.isArray(property.enum) ? property.enum : undefined;
-    };
-    const hasDefault = (name) => {
-        const property = readField(properties, name);
-        return isRecord(property) && 'default' in property;
-    };
-    const pairActions = new Set();
-    for (const entry of legacyIds) {
-        if (isRecord(entry) && typeof entry.action === 'string')
-            pairActions.add(entry.action);
-    }
-    legacyIds.forEach((entry, position) => {
-        if (!isRecord(entry) || !isRecord(entry.folded))
-            return;
-        if (position === 0) {
-            ctx.addIssue({
-                code: 'custom',
-                path: ['legacyIds', 0, 'folded'],
-                message: 'legacyIds[0] is the advertised primary and cannot be folded'
-            });
-        }
-        for (const [name, value] of Object.entries(entry.folded)) {
-            if (!Object.hasOwn(properties, name)) {
-                ctx.addIssue({
-                    code: 'custom',
-                    path: ['legacyIds', position, 'folded', name],
-                    message: 'a folded pin must name a declared input property'
-                });
-                continue;
-            }
-            const allowed = enumOf(name);
-            if (allowed !== undefined && !allowed.includes(value)) {
-                ctx.addIssue({
-                    code: 'custom',
-                    path: ['legacyIds', position, 'folded', name],
-                    message: 'a folded pin value must be one of the property enum values'
-                });
-            }
-        }
-    });
-    const routing = readField(record, 'routing');
-    const dispatchBy = isRecord(routing) ? readField(routing, 'dispatchBy') : undefined;
-    if (dispatchBy === undefined)
-        return;
-    if (!isRecord(dispatchBy) || typeof dispatchBy.param !== 'string' || !isRecord(dispatchBy.actions))
-        return;
-    const selector = dispatchBy.param;
-    const selectorRequired = required.includes(selector) && !hasDefault(selector);
-    const pinOf = (action) => {
-        for (const entry of legacyIds) {
-            if (isRecord(entry) && entry.action === action && isRecord(entry.folded)
-                && typeof entry.folded[selector] === 'string') {
-                return entry.folded[selector];
-            }
-        }
-        return undefined;
-    };
-    if (selectorRequired) {
-        legacyIds.forEach((entry, position) => {
-            if (position === 0 || !isRecord(entry) || !isRecord(entry.folded))
-                return;
-            if (pinOf(String(entry.action)) === undefined) {
-                ctx.addIssue({
-                    code: 'custom',
-                    path: ['legacyIds', position, 'folded', selector],
-                    message: `a pair folded under the required selector '${selector}' must pin that selector, or a call by its old name cannot satisfy validation`
-                });
-            }
-        });
-    }
-    const allowed = enumOf(selector);
-    if (allowed === undefined) {
-        ctx.addIssue({
-            code: 'custom',
-            path: ['routing', 'dispatchBy', 'param'],
-            message: 'dispatchBy.param must name a declared input property that declares an enum'
-        });
-        return;
-    }
-    const keys = Object.keys(dispatchBy.actions);
-    const allowedValues = allowed.filter((value) => typeof value === 'string');
-    const missing = allowedValues.filter((value) => !keys.includes(value));
-    const extra = keys.filter((key) => !allowedValues.includes(key));
-    if (missing.length > 0 || extra.length > 0) {
-        ctx.addIssue({
-            code: 'custom',
-            path: ['routing', 'dispatchBy', 'actions'],
-            message: `dispatchBy.actions keys must equal the enum of '${selector}' `
-                + `(missing: ${missing.join(', ') || 'none'}; extra: ${extra.join(', ') || 'none'})`
-        });
-    }
-    if (isRecord(dispatchBy.declaredBy)) {
-        for (const [name, values] of Object.entries(dispatchBy.declaredBy)) {
-            if (!Object.hasOwn(properties, name) || !Array.isArray(values) || !values.every((value) => keys.includes(String(value)))) {
-                ctx.addIssue({
-                    code: 'custom',
-                    path: ['routing', 'dispatchBy', 'declaredBy', name],
-                    message: 'declaredBy must name a declared input property and map it to selector values dispatchBy.actions routes'
-                });
-            }
-        }
-    }
-    for (const [value, action] of Object.entries(dispatchBy.actions)) {
-        if (typeof action !== 'string')
-            continue;
-        if (!pairActions.has(action)) {
-            ctx.addIssue({
-                code: 'custom',
-                path: ['routing', 'dispatchBy', 'actions', value],
-                message: 'a dispatchBy action must be one of the record\'s legacy pairs: its folded legacy actions or its primary'
-            });
-            continue;
-        }
-        const pin = pinOf(action);
-        if (pin !== undefined && pin !== value) {
-            ctx.addIssue({
-                code: 'custom',
-                path: ['routing', 'dispatchBy', 'actions', value],
-                message: `the pair for '${action}' pins selector '${selector}' to '${pin}', but dispatchBy maps '${value}' to it; the two call forms of one family must dispatch the same action`
-            });
-        }
-    }
-}
-//# sourceMappingURL=record-folding.js.map

package/dist/tools/catalog/capabilities/record-hashing.d.ts

@@ -1,3 +0,0 @@
-import { z } from 'zod';
-export declare function verifyHashes(record: Record<string, unknown>, ctx: z.RefinementCtx): void;
-//# sourceMappingURL=record-hashing.d.ts.map

package/dist/tools/catalog/capabilities/record-hashing.js

@@ -1,33 +0,0 @@
-import { computeCapabilityHashes, readField } from './hashing.js';
-import { isRecord } from '../../../utils/validation/type-guards.js';
-export function verifyHashes(record, ctx) {
-    const { hashes, ...source } = record;
-    const computed = computeCapabilityHashes(source);
-    if (!isRecord(hashes)) {
-        ctx.addIssue({
-            code: 'custom',
-            path: ['hashes'],
-            message: 'hashes must be a JSON object'
-        });
-        return;
-    }
-    const rawSchemaHash = readField(hashes, 'schema');
-    const schemaHash = typeof rawSchemaHash === 'string' ? rawSchemaHash : undefined;
-    const rawContentHash = readField(hashes, 'content');
-    const contentHash = typeof rawContentHash === 'string' ? rawContentHash : undefined;
-    if (computed.schema !== schemaHash) {
-        ctx.addIssue({
-            code: 'custom',
-            path: ['hashes', 'schema'],
-            message: 'schema hash mismatch'
-        });
-    }
-    if (computed.content !== contentHash) {
-        ctx.addIssue({
-            code: 'custom',
-            path: ['hashes', 'content'],
-            message: 'content hash mismatch'
-        });
-    }
-}
-//# sourceMappingURL=record-hashing.js.map

package/dist/tools/catalog/capabilities/record-schema.d.ts

@@ -1,221 +0,0 @@
-import { z } from 'zod';
-export declare const CapabilityRecordSourceSchema: z.ZodObject<{
-    id: z.core.$ZodBranded<z.ZodString, "CapabilityId", "out">;
-    aliases: z.ZodArray<z.core.$ZodBranded<z.ZodString, "CapabilityAlias", "out">>;
-    legacyIds: z.ZodArray<z.ZodObject<{
-        tool: z.core.$ZodBranded<z.ZodString, "LegacyToolName", "out">;
-        action: z.core.$ZodBranded<z.ZodString, "LegacyActionName", "out">;
-        folded: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("./model.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("./model.js").JsonValue, unknown>>>>;
-    }, z.core.$strict>>;
-    discovery: z.ZodObject<{
-        domain: z.ZodString;
-        family: z.ZodString;
-        topics: z.ZodArray<z.ZodString>;
-        summary: z.ZodString;
-        whenToUse: z.ZodArray<z.ZodString>;
-        whenNotToUse: z.ZodArray<z.ZodString>;
-    }, z.core.$strict>;
-    schemas: z.ZodObject<{
-        input: z.ZodObject<{
-            $schema: z.ZodLiteral<"https://json-schema.org/draft/2020-12/schema">;
-            type: z.ZodLiteral<"object">;
-            properties: z.ZodRecord<z.ZodString, z.ZodType<import("./model.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("./model.js").JsonValue, unknown>>>;
-            required: z.ZodArray<z.ZodString>;
-            additionalProperties: z.ZodUnion<readonly [z.ZodBoolean, z.ZodRecord<z.ZodString, z.ZodType<import("./model.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("./model.js").JsonValue, unknown>>>]>;
-            requiredOneOf: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>;
-        output: z.ZodObject<{
-            $schema: z.ZodLiteral<"https://json-schema.org/draft/2020-12/schema">;
-            type: z.ZodLiteral<"object">;
-            properties: z.ZodRecord<z.ZodString, z.ZodType<import("./model.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("./model.js").JsonValue, unknown>>>;
-            required: z.ZodArray<z.ZodString>;
-            additionalProperties: z.ZodUnion<readonly [z.ZodBoolean, z.ZodRecord<z.ZodString, z.ZodType<import("./model.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("./model.js").JsonValue, unknown>>>]>;
-            requiredOneOf: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>;
-    }, z.core.$strict>;
-    examples: z.ZodArray<z.ZodObject<{
-        title: z.ZodString;
-        input: z.ZodRecord<z.ZodString, z.ZodType<import("./model.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("./model.js").JsonValue, unknown>>>;
-        output: z.ZodRecord<z.ZodString, z.ZodType<import("./model.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("./model.js").JsonValue, unknown>>>;
-    }, z.core.$strict>>;
-    availability: z.ZodObject<{
-        requiredPlugins: z.ZodArray<z.ZodString>;
-        editorStates: z.ZodArray<z.ZodEnum<{
-            edit: "edit";
-            pie: "pie";
-            simulate: "simulate";
-        }>>;
-    }, z.core.$strict>;
-    behavior: z.ZodObject<{
-        effect: z.ZodEnum<{
-            destructive: "destructive";
-            read: "read";
-            write: "write";
-        }>;
-        idempotency: z.ZodEnum<{
-            "non-idempotent": "non-idempotent";
-            idempotent: "idempotent";
-            "idempotency-key": "idempotency-key";
-        }>;
-        longRunning: z.ZodBoolean;
-        safeToRetry: z.ZodBoolean;
-        compensation: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
-            inverse: z.ZodArray<z.core.$ZodBranded<z.ZodString, "CapabilityId", "out">>;
-        }, z.core.$strict>, z.ZodObject<{
-            guidance: z.ZodString;
-        }, z.core.$strict>]>>;
-    }, z.core.$strict>;
-    policy: z.ZodObject<{
-        requiredScope: z.ZodEnum<{
-            admin: "admin";
-            destructive: "destructive";
-            read: "read";
-            write: "write";
-        }>;
-        consent: z.ZodEnum<{
-            explicit: "explicit";
-            elevated: "elevated";
-            none: "none";
-        }>;
-        dataAccess: z.ZodEnum<{
-            none: "none";
-            "project-read": "project-read";
-            "project-write": "project-write";
-            "engine-read": "engine-read";
-        }>;
-    }, z.core.$strict>;
-    cost: z.ZodObject<{
-        latency: z.ZodEnum<{
-            instant: "instant";
-            interactive: "interactive";
-            "long-running": "long-running";
-        }>;
-        resources: z.ZodEnum<{
-            low: "low";
-            medium: "medium";
-            high: "high";
-        }>;
-    }, z.core.$strict>;
-    routing: z.ZodObject<{
-        parentTool: z.core.$ZodBranded<z.ZodString, "LegacyToolName", "out">;
-        dispatchAction: z.core.$ZodBranded<z.ZodString, "LegacyActionName", "out">;
-        dispatchBy: z.ZodOptional<z.ZodObject<{
-            param: z.ZodString;
-            actions: z.ZodRecord<z.ZodString, z.core.$ZodBranded<z.ZodString, "LegacyActionName", "out">>;
-            declaredBy: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export declare const CapabilityRecordSchema: z.ZodObject<{
-    hashes: z.ZodObject<{
-        algorithm: z.ZodLiteral<"sha256">;
-        schema: z.ZodString;
-        content: z.ZodString;
-    }, z.core.$strict>;
-    id: z.core.$ZodBranded<z.ZodString, "CapabilityId", "out">;
-    aliases: z.ZodArray<z.core.$ZodBranded<z.ZodString, "CapabilityAlias", "out">>;
-    legacyIds: z.ZodArray<z.ZodObject<{
-        tool: z.core.$ZodBranded<z.ZodString, "LegacyToolName", "out">;
-        action: z.core.$ZodBranded<z.ZodString, "LegacyActionName", "out">;
-        folded: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("./model.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("./model.js").JsonValue, unknown>>>>;
-    }, z.core.$strict>>;
-    discovery: z.ZodObject<{
-        domain: z.ZodString;
-        family: z.ZodString;
-        topics: z.ZodArray<z.ZodString>;
-        summary: z.ZodString;
-        whenToUse: z.ZodArray<z.ZodString>;
-        whenNotToUse: z.ZodArray<z.ZodString>;
-    }, z.core.$strict>;
-    schemas: z.ZodObject<{
-        input: z.ZodObject<{
-            $schema: z.ZodLiteral<"https://json-schema.org/draft/2020-12/schema">;
-            type: z.ZodLiteral<"object">;
-            properties: z.ZodRecord<z.ZodString, z.ZodType<import("./model.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("./model.js").JsonValue, unknown>>>;
-            required: z.ZodArray<z.ZodString>;
-            additionalProperties: z.ZodUnion<readonly [z.ZodBoolean, z.ZodRecord<z.ZodString, z.ZodType<import("./model.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("./model.js").JsonValue, unknown>>>]>;
-            requiredOneOf: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>;
-        output: z.ZodObject<{
-            $schema: z.ZodLiteral<"https://json-schema.org/draft/2020-12/schema">;
-            type: z.ZodLiteral<"object">;
-            properties: z.ZodRecord<z.ZodString, z.ZodType<import("./model.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("./model.js").JsonValue, unknown>>>;
-            required: z.ZodArray<z.ZodString>;
-            additionalProperties: z.ZodUnion<readonly [z.ZodBoolean, z.ZodRecord<z.ZodString, z.ZodType<import("./model.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("./model.js").JsonValue, unknown>>>]>;
-            requiredOneOf: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>;
-    }, z.core.$strict>;
-    examples: z.ZodArray<z.ZodObject<{
-        title: z.ZodString;
-        input: z.ZodRecord<z.ZodString, z.ZodType<import("./model.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("./model.js").JsonValue, unknown>>>;
-        output: z.ZodRecord<z.ZodString, z.ZodType<import("./model.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("./model.js").JsonValue, unknown>>>;
-    }, z.core.$strict>>;
-    availability: z.ZodObject<{
-        requiredPlugins: z.ZodArray<z.ZodString>;
-        editorStates: z.ZodArray<z.ZodEnum<{
-            edit: "edit";
-            pie: "pie";
-            simulate: "simulate";
-        }>>;
-    }, z.core.$strict>;
-    behavior: z.ZodObject<{
-        effect: z.ZodEnum<{
-            destructive: "destructive";
-            read: "read";
-            write: "write";
-        }>;
-        idempotency: z.ZodEnum<{
-            "non-idempotent": "non-idempotent";
-            idempotent: "idempotent";
-            "idempotency-key": "idempotency-key";
-        }>;
-        longRunning: z.ZodBoolean;
-        safeToRetry: z.ZodBoolean;
-        compensation: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
-            inverse: z.ZodArray<z.core.$ZodBranded<z.ZodString, "CapabilityId", "out">>;
-        }, z.core.$strict>, z.ZodObject<{
-            guidance: z.ZodString;
-        }, z.core.$strict>]>>;
-    }, z.core.$strict>;
-    policy: z.ZodObject<{
-        requiredScope: z.ZodEnum<{
-            admin: "admin";
-            destructive: "destructive";
-            read: "read";
-            write: "write";
-        }>;
-        consent: z.ZodEnum<{
-            explicit: "explicit";
-            elevated: "elevated";
-            none: "none";
-        }>;
-        dataAccess: z.ZodEnum<{
-            none: "none";
-            "project-read": "project-read";
-            "project-write": "project-write";
-            "engine-read": "engine-read";
-        }>;
-    }, z.core.$strict>;
-    cost: z.ZodObject<{
-        latency: z.ZodEnum<{
-            instant: "instant";
-            interactive: "interactive";
-            "long-running": "long-running";
-        }>;
-        resources: z.ZodEnum<{
-            low: "low";
-            medium: "medium";
-            high: "high";
-        }>;
-    }, z.core.$strict>;
-    routing: z.ZodObject<{
-        parentTool: z.core.$ZodBranded<z.ZodString, "LegacyToolName", "out">;
-        dispatchAction: z.core.$ZodBranded<z.ZodString, "LegacyActionName", "out">;
-        dispatchBy: z.ZodOptional<z.ZodObject<{
-            param: z.ZodString;
-            actions: z.ZodRecord<z.ZodString, z.core.$ZodBranded<z.ZodString, "LegacyActionName", "out">>;
-            declaredBy: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-//# sourceMappingURL=record-schema.d.ts.map

package/dist/tools/catalog/capabilities/record-schema.js

@@ -1,22 +0,0 @@
-import { z } from 'zod';
-import { hashesSchema, sourceShape } from './record-fields.js';
-import { verifyFolding } from './record-folding.js';
-import { verifyHashes } from './record-hashing.js';
-import { isRecord } from '../../../utils/validation/type-guards.js';
-export const CapabilityRecordSourceSchema = z
-    .strictObject(sourceShape)
-    .superRefine((record, ctx) => {
-    if (!isRecord(record))
-        return;
-    verifyFolding(record, ctx);
-});
-const recordShape = { ...sourceShape, hashes: hashesSchema };
-export const CapabilityRecordSchema = z
-    .strictObject(recordShape)
-    .superRefine((record, ctx) => {
-    if (!isRecord(record))
-        return;
-    verifyFolding(record, ctx);
-    verifyHashes(record, ctx);
-});
-//# sourceMappingURL=record-schema.js.map

package/dist/tools/catalog/capabilities/records/aggregate.d.ts

@@ -1,4 +0,0 @@
-import type { CapabilityRecord } from '../model.js';
-export declare const ALL_CAPABILITY_RECORD_COUNT: 405;
-export declare const ALL_CAPABILITY_RECORDS: readonly CapabilityRecord[];
-//# sourceMappingURL=aggregate.d.ts.map

package/dist/tools/catalog/capabilities/records/aggregate.js

@@ -1,60 +0,0 @@
-import { createCapabilityRecord, parseCapabilityCatalog } from '../parser.js';
-import { BUILD_ENVIRONMENT_SOURCES } from './build-environment/index.js';
-import { CONTROL_ACTOR_SOURCES } from './control-actor/index.js';
-import { CONTROL_EDITOR_SOURCES } from './control-editor/index.js';
-import { ANIMATION_PHYSICS_SOURCES } from './gameplay/animation-physics/index.js';
-import { MANAGE_AI_SOURCES } from './gameplay/manage-ai/records.js';
-import { MANAGE_CHARACTER_SOURCES } from './gameplay/manage-character/index.js';
-import { MANAGE_COMBAT_SOURCES } from './gameplay/manage-combat/index.js';
-import { MANAGE_EFFECT_SOURCES } from './gameplay/manage-effect/index.js';
-import { MANAGE_GAS_SOURCES } from './gameplay/manage-gas/index.js';
-import { MANAGE_INTERACTION_SOURCES } from './gameplay/manage-interaction/index.js';
-import { MANAGE_INVENTORY_SOURCES } from './gameplay/manage-inventory/index.js';
-import { INSPECT_SOURCES } from './inspect/index.js';
-import { MANAGE_ASSET_SOURCES } from './manage-asset/index.js';
-import { MANAGE_AUDIO_SOURCES } from './manage-audio/index.js';
-import { MANAGE_BLUEPRINT_SOURCES } from './manage-blueprint/index.js';
-import { MANAGE_LEVEL_SOURCES } from './manage-level/index.js';
-import { MANAGE_NETWORKING_SOURCES } from './manage-networking/index.js';
-import { MANAGE_SEQUENCE_SOURCES } from './manage-sequence/index.js';
-import { MANAGE_TOOLS_SOURCES } from './manage-tools/index.js';
-import { SYSTEM_CONTROL_SOURCES } from './system-control/index.js';
-import { MANAGE_GEOMETRY_SOURCES } from './world/manage-geometry.index.js';
-import { MANAGE_LEVEL_STRUCTURE_SOURCES } from './world/manage-level-structure.index.js';
-import { MANAGE_PCG_SOURCES } from './world/manage-pcg.index.js';
-export const ALL_CAPABILITY_RECORD_COUNT = 405;
-const ALL_SOURCES = [
-    ...BUILD_ENVIRONMENT_SOURCES,
-    ...MANAGE_LEVEL_STRUCTURE_SOURCES,
-    ...MANAGE_GEOMETRY_SOURCES,
-    ...MANAGE_PCG_SOURCES,
-    ...ANIMATION_PHYSICS_SOURCES,
-    ...MANAGE_EFFECT_SOURCES,
-    ...MANAGE_GAS_SOURCES,
-    ...MANAGE_CHARACTER_SOURCES,
-    ...MANAGE_COMBAT_SOURCES,
-    ...MANAGE_AI_SOURCES,
-    ...MANAGE_INVENTORY_SOURCES,
-    ...MANAGE_INTERACTION_SOURCES,
-    ...MANAGE_SEQUENCE_SOURCES,
-    ...MANAGE_AUDIO_SOURCES,
-    ...MANAGE_NETWORKING_SOURCES,
-    ...MANAGE_ASSET_SOURCES,
-    ...MANAGE_BLUEPRINT_SOURCES,
-    ...CONTROL_ACTOR_SOURCES,
-    ...CONTROL_EDITOR_SOURCES,
-    ...MANAGE_LEVEL_SOURCES,
-    ...SYSTEM_CONTROL_SOURCES,
-    ...INSPECT_SOURCES,
-    ...MANAGE_TOOLS_SOURCES,
-];
-export const ALL_CAPABILITY_RECORDS = (() => {
-    const parsed = parseCapabilityCatalog(ALL_SOURCES.map(createCapabilityRecord));
-    const uniqueIdCount = new Set(parsed.map((record) => record.id)).size;
-    if (parsed.length !== ALL_CAPABILITY_RECORD_COUNT || uniqueIdCount !== ALL_CAPABILITY_RECORD_COUNT) {
-        throw new TypeError(`Capability record aggregate must contain exactly ${ALL_CAPABILITY_RECORD_COUNT} `
-            + `records and unique IDs; received ${parsed.length} records and ${uniqueIdCount} unique IDs`);
-    }
-    return Object.freeze(parsed);
-})();
-//# sourceMappingURL=aggregate.js.map

package/dist/tools/catalog/capabilities/records/build-environment/atmosphere.data.d.ts

@@ -1,3 +0,0 @@
-import type { CapabilityRecordSource } from '../../model.js';
-export declare const ATMOSPHERE_RECORDS: readonly CapabilityRecordSource[];
-//# sourceMappingURL=atmosphere.data.d.ts.map

package/dist/tools/catalog/capabilities/records/build-environment/atmosphere.data.js

@@ -1,124 +0,0 @@
-import { buildRecord } from './helpers.js';
-import { P } from './properties.js';
-import { num } from '../shared/schema-props.js';
-const F = 'atmosphere';
-const WU = ['Atmosphere, sky, fog, or time-of-day must be configured.'];
-const TARGET = {
-    actorName: { ...P.actorName, description: 'Label of the actor to configure; the first one of its kind in the level when omitted. One is spawned with this label when none exists.' },
-    location: { ...P.location, description: 'Where the actor is spawned when the level has none; an existing actor is not moved.' },
-};
-const ROTATED = { ...TARGET, rotation: { ...P.rotation, description: 'Actor rotation, applied on every call.' } };
-const CURVE_PATH = { ...P.curvePath, description: 'The curve asset to edit, created there when missing (default /Game/Environment/Curves/MCP_SkyColorCurve or MCP_LightColorCurve).' };
-const CURVE_KEYS = {
-    type: 'array', minItems: 1,
-    description: 'Color keys that replace the curve\'s keys; required to change an existing curve. A new curve without keys is flat white.',
-    items: {
-        type: 'object', description: 'One key.',
-        properties: {
-            time: num('Key time, e.g. the hour of day.'),
-            color: { type: 'object', description: 'Color {r, g, b, a}; a defaults to 1.', properties: { r: num('Red.'), g: num('Green.'), b: num('Blue.'), a: num('Alpha.') }, additionalProperties: false },
-        },
-        required: ['time', 'color'], additionalProperties: false,
-    },
-};
-export const ATMOSPHERE_RECORDS = [
-    buildRecord({
-        id: 'build_environment.create_sky_sphere', action: 'create_sky_sphere', family: F,
-        summary: 'Create a sky rig: a sky atmosphere, a sun (directional light) and a sky light, labelled <name>_Atmosphere, _Sun and _SkyLight.',
-        whenToUse: WU, whenNotToUse: ['A sky atmosphere is already present.'],
-        inputProps: { name: P.name, location: P.location },
-        required: [], effect: 'write', latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'create_sky_sphere', name: 'SkySphere_1' },
-    }),
-    buildRecord({
-        id: 'build_environment.set_time_of_day', action: 'set_time_of_day', family: F,
-        summary: 'Set the time of day: the hour sets the sun\'s elevation (azimuth and elevation may be given directly).',
-        whenToUse: WU, whenNotToUse: ['A full time-of-day system should be created.'],
-        inputProps: { time: P.time, hour: P.hour, azimuth: P.azimuth, elevation: P.elevation, settings: P.actorSettings, ...TARGET },
-        required: [], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'instant', resources: 'low',
-        exampleInput: { action: 'set_time_of_day', time: 14.5 },
-    }),
-    buildRecord({
-        id: 'build_environment.create_time_of_day_system', action: 'create_time_of_day_system', family: F,
-        summary: 'Create a full time-of-day system with sun and sky curves.',
-        whenToUse: WU, whenNotToUse: ['A static time should be set instead.'],
-        inputProps: { name: P.name, location: P.location },
-        required: [], effect: 'write', latency: 'interactive', resources: 'medium',
-        exampleInput: { action: 'create_time_of_day_system', name: 'TOD_1' },
-    }),
-    buildRecord({
-        id: 'build_environment.create_fog_volume', action: 'create_fog_volume', family: F,
-        summary: 'Create (or find by name) an exponential height fog actor.',
-        whenToUse: WU, whenNotToUse: ['Exponential height fog is sufficient.'],
-        inputProps: { name: P.name, location: P.location, rotation: P.rotation, density: P.density, settings: P.actorSettings },
-        required: [], effect: 'write', latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'create_fog_volume', name: 'FogVol_1', location: { x: 0, y: 0, z: 0 } },
-    }),
-    buildRecord({
-        id: 'build_environment.configure_sky_atmosphere', action: 'configure_sky_atmosphere', family: F,
-        summary: 'Configure sky atmosphere settings.',
-        whenToUse: WU, whenNotToUse: ['Default atmosphere is sufficient.'],
-        inputProps: { settings: P.actorSettings, ...ROTATED },
-        required: [], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_sky_atmosphere', settings: { MieScatteringScale: 0.1 } },
-    }),
-    buildRecord({
-        id: 'build_environment.configure_sky_light', action: 'configure_sky_light', family: F,
-        summary: 'Configure sky light intensity and cubemap.',
-        whenToUse: WU, whenNotToUse: ['Default sky light is sufficient.'],
-        inputProps: { skyLightIntensity: P.skyLightIntensity,
-            cubemapPath: { ...P.cubemapPath, description: 'Cube texture the sky light uses (switches its source to a specified cubemap); a path that does not load fails the call.' },
-            settings: P.actorSettings, ...ROTATED },
-        required: [], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_sky_light', skyLightIntensity: 1.0 },
-    }),
-    buildRecord({
-        id: 'build_environment.configure_directional_light_atmosphere', action: 'configure_directional_light_atmosphere', family: F,
-        summary: 'Configure a directional light: its angle (azimuth, elevation above the horizon), intensity, and any light property such as LightColor through settings.',
-        whenToUse: WU, whenNotToUse: ['Default atmosphere is sufficient.'],
-        inputProps: { azimuth: P.azimuth, elevation: P.elevation, intensity: P.intensity, settings: P.actorSettings, ...TARGET },
-        required: [], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_directional_light_atmosphere', actorName: 'DirectionalLight_1', azimuth: 45, elevation: 30 },
-    }),
-    buildRecord({
-        id: 'build_environment.configure_exponential_height_fog', action: 'configure_exponential_height_fog', family: F,
-        summary: 'Configure exponential height fog settings.',
-        whenToUse: WU, whenNotToUse: ['Volumetric fog should be used instead.'],
-        inputProps: { settings: P.actorSettings, density: P.density, ...ROTATED },
-        required: [], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_exponential_height_fog', density: 0.05 },
-    }),
-    buildRecord({
-        id: 'build_environment.configure_volumetric_cloud', action: 'configure_volumetric_cloud', family: F,
-        summary: 'Configure volumetric cloud settings.',
-        whenToUse: WU, whenNotToUse: ['Static cloud textures are sufficient.'],
-        inputProps: { settings: P.actorSettings, ...ROTATED },
-        required: [], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_volumetric_cloud', settings: { LayerBottomAltitude: 2 } },
-    }),
-    buildRecord({
-        id: 'build_environment.configure_sun_position', action: 'configure_sun_position', family: F,
-        summary: 'Configure sun azimuth and elevation (or an hour of day) on the level\'s sun.',
-        whenToUse: WU, whenNotToUse: ['The sun should follow a time-of-day system.'],
-        inputProps: { azimuth: P.azimuth, elevation: P.elevation, time: P.time, hour: P.hour, settings: P.actorSettings, ...TARGET },
-        required: [], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'instant', resources: 'low',
-        exampleInput: { action: 'configure_sun_position', azimuth: 45, elevation: 60 },
-    }),
-    buildRecord({
-        id: 'build_environment.configure_light_color_curve', action: 'configure_light_color_curve', family: F,
-        summary: 'Set the color keys of a light color curve asset (made at curvePath when missing) for time-of-day.',
-        whenToUse: WU, whenNotToUse: ['Static light color is sufficient.'],
-        inputProps: { curvePath: CURVE_PATH, keys: CURVE_KEYS },
-        required: [], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_light_color_curve', curvePath: '/Game/Curves/LightColor', keys: [{ time: 6, color: { r: 1, g: 0.6, b: 0.3 } }, { time: 12, color: { r: 1, g: 1, b: 0.95 } }] },
-    }),
-    buildRecord({
-        id: 'build_environment.configure_sky_color_curve', action: 'configure_sky_color_curve', family: F,
-        summary: 'Set the color keys of a sky color curve asset (made at curvePath when missing) for time-of-day.',
-        whenToUse: WU, whenNotToUse: ['Static sky color is sufficient.'],
-        inputProps: { curvePath: CURVE_PATH, keys: CURVE_KEYS },
-        required: [], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_sky_color_curve', curvePath: '/Game/Curves/SkyColor', keys: [{ time: 0, color: { r: 0.05, g: 0.05, b: 0.2 } }, { time: 12, color: { r: 0.4, g: 0.6, b: 1 } }] },
-    }),
-];
-//# sourceMappingURL=atmosphere.data.js.map

package/dist/tools/catalog/capabilities/records/build-environment/foliage.data.d.ts

@@ -1,3 +0,0 @@
-import type { CapabilityRecordSource } from '../../model.js';
-export declare const FOLIAGE_RECORDS: readonly CapabilityRecordSource[];
-//# sourceMappingURL=foliage.data.d.ts.map