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

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

@@ -1,14 +0,0 @@
-export declare class CapabilitySerializationError extends Error {
-    readonly code: "CAPABILITY_SERIALIZATION_ERROR";
-    constructor(message: string);
-}
-export declare function stableJsonStringify(value: unknown): string;
-export type CapabilityHashBundle = {
-    readonly algorithm: 'sha256';
-    readonly schema: string;
-    readonly content: string;
-};
-export declare function readField(source: unknown, key: string): unknown;
-export declare function computeCapabilityHashes(source: unknown): CapabilityHashBundle;
-export declare function stripUndefined(value: unknown): unknown;
-//# sourceMappingURL=hashing.d.ts.map

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

@@ -1,80 +0,0 @@
-import { createHash } from 'node:crypto';
-export class CapabilitySerializationError extends Error {
-    code = 'CAPABILITY_SERIALIZATION_ERROR';
-    constructor(message) {
-        super(message);
-        this.name = 'CapabilitySerializationError';
-    }
-}
-function isPlainObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function normalize(value) {
-    if (typeof value === 'bigint') {
-        throw new CapabilitySerializationError('Capability hash input must not contain bigint');
-    }
-    if (typeof value === 'function' ||
-        typeof value === 'symbol' ||
-        typeof value === 'undefined') {
-        throw new CapabilitySerializationError('Capability hash input must be JSON-compatible');
-    }
-    if (typeof value === 'number') {
-        if (Number.isNaN(value) || !Number.isFinite(value)) {
-            throw new CapabilitySerializationError('Capability hash input must not contain NaN or Infinity');
-        }
-        if (value === 0 && 1 / value < 0)
-            return 0;
-        return value;
-    }
-    if (Array.isArray(value))
-        return value.map(normalize);
-    if (isPlainObject(value)) {
-        const out = {};
-        for (const key of Object.keys(value).sort())
-            out[key] = normalize(value[key]);
-        return out;
-    }
-    return value;
-}
-export function stableJsonStringify(value) {
-    return JSON.stringify(normalize(value));
-}
-function sha256Hex(input) {
-    return createHash('sha256').update(input).digest('hex');
-}
-export function readField(source, key) {
-    return isPlainObject(source) ? source[key] : undefined;
-}
-export function computeCapabilityHashes(source) {
-    const record = isPlainObject(source) ? source : {};
-    const rawSchemas = readField(record, 'schemas');
-    const schemas = isPlainObject(rawSchemas) ? rawSchemas : {};
-    const input = readField(schemas, 'input');
-    const output = readField(schemas, 'output');
-    const schemaHash = sha256Hex(stableJsonStringify({ input, output }));
-    const contentHash = sha256Hex(stableJsonStringify({ ...record, schemaHash }));
-    return { algorithm: 'sha256', schema: schemaHash, content: contentHash };
-}
-export function stripUndefined(value) {
-    if (Array.isArray(value))
-        return value.map(stripUndefined);
-    if (value !== null && typeof value === 'object') {
-        const out = {};
-        for (const [key, entry] of Object.entries(value)) {
-            if (entry === undefined)
-                continue;
-            const shaped = stripUndefined(entry);
-            if (key === '__proto__') {
-                Object.defineProperty(out, key, {
-                    value: shaped, enumerable: true, writable: true, configurable: true,
-                });
-            }
-            else {
-                out[key] = shaped;
-            }
-        }
-        return out;
-    }
-    return value;
-}
-//# sourceMappingURL=hashing.js.map

package/dist/tools/catalog/capabilities/identifiers.d.ts

@@ -1,21 +0,0 @@
-import { z } from 'zod';
-export declare const CapabilityIdSchema: z.core.$ZodBranded<z.ZodString, "CapabilityId", "out">;
-export declare const CapabilityAliasSchema: z.core.$ZodBranded<z.ZodString, "CapabilityAlias", "out">;
-export declare const LegacyToolNameSchema: z.core.$ZodBranded<z.ZodString, "LegacyToolName", "out">;
-export declare const LegacyActionNameSchema: z.core.$ZodBranded<z.ZodString, "LegacyActionName", "out">;
-export declare const UnrealVersionSchema: z.ZodReadonly<z.ZodObject<{
-    major: z.ZodLiteral<5>;
-    minor: z.ZodNumber;
-    patch: z.ZodNumber;
-    channel: z.ZodEnum<{
-        stable: "stable";
-        preview: "preview";
-    }>;
-    preview: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strict>>;
-export type CapabilityId = z.infer<typeof CapabilityIdSchema>;
-export type CapabilityAlias = z.infer<typeof CapabilityAliasSchema>;
-export type LegacyToolName = z.infer<typeof LegacyToolNameSchema>;
-export type LegacyActionName = z.infer<typeof LegacyActionNameSchema>;
-export type UnrealVersion = z.infer<typeof UnrealVersionSchema>;
-//# sourceMappingURL=identifiers.d.ts.map

package/dist/tools/catalog/capabilities/identifiers.js

@@ -1,47 +0,0 @@
-import { z } from 'zod';
-import { UNREAL_RELEASE_CHANNELS } from './constants.js';
-const canonicalIdPattern = /^[a-z][a-z0-9_]*(?:\.[a-z][a-z0-9_]*)+$/;
-const legacyNamePattern = /^[a-z][a-z0-9_]*$/;
-export const CapabilityIdSchema = z.string()
-    .min(3)
-    .max(160)
-    .regex(canonicalIdPattern, 'Expected a lower-snake-case dotted capability ID')
-    .brand();
-export const CapabilityAliasSchema = z.string()
-    .min(3)
-    .max(160)
-    .regex(canonicalIdPattern, 'Expected a lower-snake-case dotted capability alias')
-    .brand();
-export const LegacyToolNameSchema = z.string()
-    .min(1)
-    .max(80)
-    .regex(legacyNamePattern, 'Expected a lower-snake-case legacy tool name')
-    .brand();
-export const LegacyActionNameSchema = z.string()
-    .min(1)
-    .max(120)
-    .regex(legacyNamePattern, 'Expected a lower-snake-case legacy action name')
-    .brand();
-export const UnrealVersionSchema = z.strictObject({
-    major: z.literal(5),
-    minor: z.number().int().min(0).max(99),
-    patch: z.number().int().min(0).max(999),
-    channel: z.enum(UNREAL_RELEASE_CHANNELS),
-    preview: z.number().int().positive().max(99).optional()
-}).readonly().superRefine((version, context) => {
-    if (version.channel === 'preview' && version.preview === undefined) {
-        context.addIssue({
-            code: 'custom',
-            path: ['preview'],
-            message: 'Preview releases require a positive preview number'
-        });
-    }
-    if (version.channel === 'stable' && version.preview !== undefined) {
-        context.addIssue({
-            code: 'custom',
-            path: ['preview'],
-            message: 'Stable releases cannot declare a preview number'
-        });
-    }
-});
-//# sourceMappingURL=identifiers.js.map

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

@@ -1,12 +0,0 @@
-import { z } from 'zod';
-import type { JsonValue } from './model.js';
-export declare const jsonObjectSchema: z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
-export declare const Draft202012ObjectSchemaSchema: z.ZodObject<{
-    $schema: z.ZodLiteral<"https://json-schema.org/draft/2020-12/schema">;
-    type: z.ZodLiteral<"object">;
-    properties: z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
-    required: z.ZodArray<z.ZodString>;
-    additionalProperties: z.ZodUnion<readonly [z.ZodBoolean, z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>]>;
-    requiredOneOf: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strict>;
-//# sourceMappingURL=json-schema.d.ts.map

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

@@ -1,71 +0,0 @@
-import { z } from 'zod';
-import { DRAFT_2020_12_SCHEMA_URI } from './constants.js';
-import { isRecord } from '../../../utils/validation/type-guards.js';
-const REFLECTION_MARKER = 'x-unreal-reflection-boundary';
-const jsonValueSchema = z.lazy(() => z.union([
-    z.string(),
-    z.number(),
-    z.boolean(),
-    z.null(),
-    z.array(jsonValueSchema),
-    z.record(z.string(), jsonValueSchema)
-]));
-export const jsonObjectSchema = z.record(z.string(), jsonValueSchema);
-function isUnboundedObject(node) {
-    if (node.type !== 'object')
-        return false;
-    const additional = node.additionalProperties;
-    const unbounded = additional === true || additional === undefined;
-    return unbounded && node[REFLECTION_MARKER] !== true;
-}
-function walk(node, path, ctx) {
-    if (typeof node === 'function' || typeof node === 'symbol') {
-        ctx.addIssue({
-            code: 'custom',
-            path: [...path],
-            message: 'JSON Schema must be JSON-compatible'
-        });
-        return;
-    }
-    if (Array.isArray(node)) {
-        node.forEach((item, index) => {
-            walk(item, [...path, String(index)], ctx);
-        });
-        return;
-    }
-    if (isRecord(node)) {
-        if (isUnboundedObject(node)) {
-            ctx.addIssue({
-                code: 'custom',
-                path: [...path],
-                message: 'Unbounded object schema requires x-unreal-reflection-boundary: true'
-            });
-        }
-        for (const key of Object.keys(node))
-            walk(node[key], [...path, key], ctx);
-    }
-}
-export const Draft202012ObjectSchemaSchema = z
-    .strictObject({
-    $schema: z.literal(DRAFT_2020_12_SCHEMA_URI),
-    type: z.literal('object'),
-    properties: jsonObjectSchema,
-    required: z.array(z.string()),
-    additionalProperties: z.union([z.boolean(), jsonObjectSchema]),
-    requiredOneOf: z.array(z.string()).min(1).optional()
-})
-    .superRefine((schema, ctx) => {
-    if (schema.requiredOneOf !== undefined) {
-        schema.requiredOneOf.forEach((name, index) => {
-            if (!Object.hasOwn(schema.properties, name)) {
-                ctx.addIssue({
-                    code: 'custom',
-                    path: ['requiredOneOf', index],
-                    message: `requiredOneOf member '${name}' must reference a declared property`
-                });
-            }
-        });
-    }
-    walk(schema, [], ctx);
-});
-//# sourceMappingURL=json-schema.js.map

package/dist/tools/catalog/capabilities/model.d.ts

@@ -1,100 +0,0 @@
-import type { BEHAVIOR_EFFECTS, CONSENT_MODES, DATA_ACCESS_CLASSES, EDITOR_STATES, HASH_ALGORITHM, IDEMPOTENCY_CLASSES, LATENCY_CLASSES, POLICY_SCOPES, RESOURCE_CLASSES } from './constants.js';
-import type { CapabilityAlias, CapabilityId, LegacyActionName, LegacyToolName } from './identifiers.js';
-export type JsonPrimitive = string | number | boolean | null;
-export type JsonValue = JsonPrimitive | JsonObject | readonly JsonValue[];
-export type JsonObject = {
-    readonly [key: string]: JsonValue;
-};
-export type Draft202012ObjectSchema = JsonObject & {
-    readonly $schema: 'https://json-schema.org/draft/2020-12/schema';
-    readonly type: 'object';
-    readonly properties: JsonObject;
-    readonly required: readonly string[];
-    readonly additionalProperties: boolean | JsonObject;
-    readonly requiredOneOf?: readonly string[];
-};
-export type LegacyCapabilityId = {
-    readonly tool: LegacyToolName;
-    readonly action: LegacyActionName;
-    readonly folded?: JsonObject;
-};
-export type CapabilityDiscovery = {
-    readonly domain: string;
-    readonly family: string;
-    readonly topics: readonly string[];
-    readonly summary: string;
-    readonly whenToUse: readonly string[];
-    readonly whenNotToUse: readonly string[];
-};
-export type CapabilitySchemas = {
-    readonly input: Draft202012ObjectSchema;
-    readonly output: Draft202012ObjectSchema;
-};
-export type CapabilityExample = {
-    readonly title: string;
-    readonly input: JsonObject;
-    readonly output: JsonObject;
-};
-export type CapabilityAvailability = {
-    readonly requiredPlugins: readonly string[];
-    readonly editorStates: readonly (typeof EDITOR_STATES)[number][];
-};
-export type CapabilityCompensation = {
-    readonly inverse: readonly CapabilityId[];
-} | {
-    readonly guidance: string;
-};
-export type CapabilityBehavior = {
-    readonly effect: (typeof BEHAVIOR_EFFECTS)[number];
-    readonly idempotency: (typeof IDEMPOTENCY_CLASSES)[number];
-    readonly longRunning: boolean;
-    readonly safeToRetry: boolean;
-    readonly compensation?: CapabilityCompensation;
-};
-export type CapabilityBehaviorSource = CapabilityBehavior;
-export type CapabilityPolicy = {
-    readonly requiredScope: (typeof POLICY_SCOPES)[number];
-    readonly consent: (typeof CONSENT_MODES)[number];
-    readonly dataAccess: (typeof DATA_ACCESS_CLASSES)[number];
-};
-export type CapabilityCost = {
-    readonly latency: (typeof LATENCY_CLASSES)[number];
-    readonly resources: (typeof RESOURCE_CLASSES)[number];
-};
-export type CapabilityDispatchBy = {
-    readonly param: string;
-    readonly actions: {
-        readonly [value: string]: LegacyActionName;
-    };
-    readonly declaredBy?: {
-        readonly [param: string]: readonly string[];
-    };
-};
-export type CapabilityRouting = {
-    readonly parentTool: LegacyToolName;
-    readonly dispatchAction: LegacyActionName;
-    readonly dispatchBy?: CapabilityDispatchBy;
-};
-export type CapabilityHashes = {
-    readonly algorithm: typeof HASH_ALGORITHM;
-    readonly schema: string;
-    readonly content: string;
-};
-export type CapabilityRecordSource = {
-    readonly id: CapabilityId;
-    readonly aliases: readonly CapabilityAlias[];
-    readonly legacyIds: readonly LegacyCapabilityId[];
-    readonly discovery: CapabilityDiscovery;
-    readonly schemas: CapabilitySchemas;
-    readonly examples: readonly CapabilityExample[];
-    readonly availability: CapabilityAvailability;
-    readonly behavior: CapabilityBehaviorSource;
-    readonly policy: CapabilityPolicy;
-    readonly cost: CapabilityCost;
-    readonly routing: CapabilityRouting;
-};
-export type CapabilityRecord = CapabilityRecordSource & {
-    readonly hashes: CapabilityHashes;
-};
-export type CapabilityCatalog = readonly CapabilityRecord[];
-//# sourceMappingURL=model.d.ts.map

package/dist/tools/catalog/capabilities/model.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=model.js.map

package/dist/tools/catalog/capabilities/parser.d.ts

@@ -1,5 +0,0 @@
-import type { CapabilityCatalog, CapabilityRecord } from './model.js';
-export declare function capabilityErrorPointers(error: unknown): readonly string[];
-export declare function createCapabilityRecord(source: unknown): CapabilityRecord;
-export declare function parseCapabilityCatalog(catalog: unknown): CapabilityCatalog;
-//# sourceMappingURL=parser.d.ts.map

package/dist/tools/catalog/capabilities/parser.js

@@ -1,41 +0,0 @@
-import { ZodError } from 'zod';
-import { CapabilityCatalogSchema } from './catalog-schema.js';
-import { computeCapabilityHashes } from './hashing.js';
-import { CapabilityRecordSourceSchema } from './record-schema.js';
-import { COMPENSATION } from './records/compensation.js';
-function escapeToken(segment) {
-    return String(segment).replace(/~/g, '~0').replace(/\//g, '~1');
-}
-function toJsonPointer(path) {
-    if (path.length === 0)
-        return '';
-    return `/${path.map(escapeToken).join('/')}`;
-}
-export function capabilityErrorPointers(error) {
-    if (!(error instanceof ZodError))
-        return [''];
-    const pointers = new Set();
-    for (const issue of error.issues) {
-        if (issue.code === 'unrecognized_keys') {
-            for (const key of issue.keys) {
-                pointers.add(toJsonPointer([...issue.path, key]));
-            }
-            continue;
-        }
-        pointers.add(toJsonPointer(issue.path));
-    }
-    return [...pointers];
-}
-export function createCapabilityRecord(source) {
-    const validated = CapabilityRecordSourceSchema.parse(source);
-    const compensation = COMPENSATION.get(validated.id);
-    const enriched = compensation === undefined
-        ? validated
-        : { ...validated, behavior: { ...validated.behavior, compensation } };
-    const hashes = computeCapabilityHashes(enriched);
-    return { ...enriched, hashes };
-}
-export function parseCapabilityCatalog(catalog) {
-    return CapabilityCatalogSchema.parse(catalog);
-}
-//# sourceMappingURL=parser.js.map

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

@@ -1,114 +0,0 @@
-import { z } from 'zod';
-export declare const hashesSchema: z.ZodObject<{
-    algorithm: z.ZodLiteral<"sha256">;
-    schema: z.ZodString;
-    content: z.ZodString;
-}, z.core.$strict>;
-export declare const sourceShape: {
-    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>;
-};
-//# sourceMappingURL=record-fields.d.ts.map

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

@@ -1,91 +0,0 @@
-import { z } from 'zod';
-import { BEHAVIOR_EFFECTS, CONSENT_MODES, DATA_ACCESS_CLASSES, EDITOR_STATES, IDEMPOTENCY_CLASSES, LATENCY_CLASSES, POLICY_SCOPES, RESOURCE_CLASSES, } from './constants.js';
-import { CapabilityAliasSchema, CapabilityIdSchema, LegacyActionNameSchema, LegacyToolNameSchema, } from './identifiers.js';
-import { Draft202012ObjectSchemaSchema, jsonObjectSchema } from './json-schema.js';
-import { getParentToolMetadata } from './records/parent-metadata.js';
-const HEX64 = /^[0-9a-f]{64}$/;
-export const hashesSchema = z.strictObject({
-    algorithm: z.literal('sha256'),
-    schema: z.string().regex(HEX64, 'expected 64-char lowercase hex sha256'),
-    content: z.string().regex(HEX64, 'expected 64-char lowercase hex sha256')
-});
-const discoverySchema = z.strictObject({
-    domain: z.string(),
-    family: z.string(),
-    topics: z.array(z.string()),
-    summary: z.string(),
-    whenToUse: z.array(z.string()),
-    whenNotToUse: z.array(z.string())
-});
-const exampleSchema = z.strictObject({
-    title: z.string(),
-    input: jsonObjectSchema,
-    output: jsonObjectSchema
-});
-const availabilitySchema = z.strictObject({
-    requiredPlugins: z.array(z.string()),
-    editorStates: z.array(z.enum(EDITOR_STATES))
-});
-const behaviorSchema = z.strictObject({
-    effect: z.enum(BEHAVIOR_EFFECTS),
-    idempotency: z.enum(IDEMPOTENCY_CLASSES),
-    longRunning: z.boolean(),
-    safeToRetry: z.boolean(),
-    compensation: z.union([
-        z.strictObject({ inverse: z.array(CapabilityIdSchema).min(1) }),
-        z.strictObject({ guidance: z.string().min(1) })
-    ]).optional()
-});
-const policySchema = z.strictObject({
-    requiredScope: z.enum(POLICY_SCOPES),
-    consent: z.enum(CONSENT_MODES),
-    dataAccess: z.enum(DATA_ACCESS_CLASSES)
-});
-const costSchema = z.strictObject({
-    latency: z.enum(LATENCY_CLASSES),
-    resources: z.enum(RESOURCE_CLASSES)
-});
-const dispatchBySchema = z.strictObject({
-    param: z.string().min(1),
-    actions: z.record(z.string().min(1), LegacyActionNameSchema),
-    declaredBy: z.record(z.string().min(1), z.array(z.string().min(1)).min(1)).optional()
-});
-const isCanonicalParent = (tool) => {
-    try {
-        getParentToolMetadata(tool);
-        return true;
-    }
-    catch {
-        return false;
-    }
-};
-const routingSchema = z.strictObject({
-    parentTool: LegacyToolNameSchema.refine(isCanonicalParent, 'parentTool is not one of the 23 canonical tools'),
-    dispatchAction: LegacyActionNameSchema,
-    dispatchBy: dispatchBySchema.optional()
-});
-const legacyIdSchema = z.strictObject({
-    tool: LegacyToolNameSchema,
-    action: LegacyActionNameSchema,
-    folded: jsonObjectSchema.optional()
-});
-const legacyIdsSchema = z
-    .array(legacyIdSchema)
-    .min(1, 'a capability must declare the legacyIds pair it is reachable through');
-export const sourceShape = {
-    id: CapabilityIdSchema,
-    aliases: z.array(CapabilityAliasSchema),
-    legacyIds: legacyIdsSchema,
-    discovery: discoverySchema,
-    schemas: z.strictObject({
-        input: Draft202012ObjectSchemaSchema,
-        output: Draft202012ObjectSchemaSchema
-    }),
-    examples: z.array(exampleSchema),
-    availability: availabilitySchema,
-    behavior: behaviorSchema,
-    policy: policySchema,
-    cost: costSchema,
-    routing: routingSchema
-};
-//# sourceMappingURL=record-fields.js.map

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

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