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

package/dist/tools/catalog/capabilities/retrieval/scoring.js

@@ -1,289 +0,0 @@
-import { compareAscii as compareCanonicalCapabilityIds } from '../../../../utils/serialization/ordering.js';
-import { canonicalCapabilityId, deriveAliasFold } from './alias-fold.js';
-import { MAX_MATCH_REASONS, MAX_REASON_TOKENS, RETRIEVAL_COVERAGE_FIELDS, RETRIEVAL_FIELD_WEIGHTS, RETRIEVAL_FUNCTION_WORDS, RETRIEVAL_NAME_FIELDS, RETRIEVAL_DELETE_INTENT_WORDS, RETRIEVAL_READ_INTENT_WORDS, RETRIEVAL_SCORE_CONSTANTS, SCORE_TIE_EPSILON, } from './constants.js';
-import { queryCapabilityTokens, tokenizeCapabilityText, uniqueCapabilityTokens } from './tokenize.js';
-function aliasAction(alias) {
-    return alias.slice(alias.lastIndexOf('.') + 1);
-}
-function indexedField(field, values) {
-    const every = values.flatMap((value) => tokenizeCapabilityText(value));
-    const tokens = RETRIEVAL_NAME_FIELDS.has(field) ? [...new Set(every)] : every;
-    const counts = new Map();
-    for (const token of tokens)
-        counts.set(token, (counts.get(token) ?? 0) + 1);
-    return Object.freeze({ field, tokens: Object.freeze(tokens), counts });
-}
-const VARIANT_LABEL = /^[A-Za-z]\w*=[\w|]+: /u;
-const guidance = (lines) => lines.map((line) => line.replace(VARIANT_LABEL, ''));
-function searchFields(record) {
-    const foldedActions = new Set(record.legacyIds.filter((legacy) => legacy.folded !== undefined).map((legacy) => String(legacy.action)));
-    const declaredAliases = record.aliases.filter((alias) => !foldedActions.has(aliasAction(String(alias))));
-    return Object.freeze([
-        indexedField('canonical_id', [record.id]),
-        indexedField('alias', declaredAliases),
-        indexedField('legacy_tool', record.legacyIds.map((legacy) => legacy.tool)),
-        indexedField('legacy_action', [
-            ...record.legacyIds.map((legacy) => legacy.action),
-            ...record.aliases.map((alias) => aliasAction(String(alias))),
-        ]),
-        indexedField('domain', [record.discovery.domain]),
-        indexedField('family', [record.discovery.family]),
-        indexedField('topic', record.discovery.topics),
-        indexedField('summary', [record.discovery.summary]),
-        indexedField('when_to_use', guidance(record.discovery.whenToUse)),
-        indexedField('when_not_to_use', guidance(record.discovery.whenNotToUse)),
-    ]);
-}
-function projectionKey(field) {
-    return [...field.counts]
-        .sort(([left], [right]) => compareCanonicalCapabilityIds(left, right))
-        .map(([token, count]) => `${token}\u0000${count}`)
-        .join('\u0001');
-}
-function collapseProjections(fields) {
-    const strongest = new Map();
-    for (const field of fields) {
-        if (field.tokens.length === 0)
-            continue;
-        const key = projectionKey(field);
-        const held = strongest.get(key);
-        if (held === undefined || outranks(field, held))
-            strongest.set(key, field);
-    }
-    const kept = new Set(strongest.values());
-    return Object.freeze(fields.filter((field) => kept.has(field)));
-}
-function outranks(candidate, held) {
-    const difference = RETRIEVAL_FIELD_WEIGHTS[candidate.field] - RETRIEVAL_FIELD_WEIGHTS[held.field];
-    if (difference !== 0)
-        return difference > 0;
-    return compareCanonicalCapabilityIds(candidate.field, held.field) < 0;
-}
-function identifierSequences(record) {
-    return Object.freeze([
-        ...record.legacyIds.map((legacy) => tokenizeCapabilityText(legacy.action)),
-        ...record.aliases.map((alias) => tokenizeCapabilityText(aliasAction(String(alias)))),
-        tokenizeCapabilityText(record.id),
-    ]);
-}
-export function createCapabilitySearchIndex(records) {
-    const aliasFold = deriveAliasFold(records);
-    const documents = records
-        .map((record) => {
-        const legacy = record.legacyIds;
-        const fields = searchFields(record);
-        const aliases = record.aliases;
-        return Object.freeze({
-            record,
-            fields,
-            scoredFields: collapseProjections(fields),
-            sequences: identifierSequences(record),
-            idTokens: tokenizeCapabilityText(record.id),
-            aliasTokens: Object.freeze(aliases.map((alias) => tokenizeCapabilityText(alias))),
-            aliasActionTokens: Object.freeze(aliases.map((alias) => tokenizeCapabilityText(aliasAction(alias)))),
-            legacyPairTokens: Object.freeze(legacy.map((entry) => tokenizeCapabilityText(`${entry.tool} ${entry.action}`))),
-            legacyActionTokens: Object.freeze(legacy.map((entry) => tokenizeCapabilityText(entry.action))),
-            actionTokenSets: Object.freeze([
-                ...record.legacyIds.map((entry) => uniqueCapabilityTokens(entry.action)),
-                ...record.aliases.map((alias) => uniqueCapabilityTokens(aliasAction(String(alias)))),
-            ]),
-        });
-    })
-        .sort((left, right) => compareCanonicalCapabilityIds(left.record.id, right.record.id));
-    const documentFrequency = new Map();
-    const fieldLengths = new Map();
-    for (const document of documents) {
-        const documentTokens = new Set(document.fields.flatMap((field) => field.tokens));
-        for (const token of documentTokens) {
-            documentFrequency.set(token, (documentFrequency.get(token) ?? 0) + 1);
-        }
-        for (const field of document.fields) {
-            fieldLengths.set(field.field, (fieldLengths.get(field.field) ?? 0) + field.tokens.length);
-        }
-    }
-    const averageFieldLengths = new Map();
-    for (const [field, length] of fieldLengths) {
-        averageFieldLengths.set(field, documents.length === 0 ? 1 : length / documents.length);
-    }
-    return Object.freeze({
-        documents: Object.freeze(documents),
-        documentFrequency,
-        averageFieldLengths,
-        aliasFold,
-    });
-}
-function queryTokenWeight(token) {
-    return RETRIEVAL_FUNCTION_WORDS.has(token)
-        ? RETRIEVAL_SCORE_CONSTANTS.functionWordWeight
-        : 1;
-}
-function scoreField(field, context) {
-    const matchedTokens = [];
-    let score = 0;
-    const averageLength = context.index.averageFieldLengths.get(field.field) ?? 1;
-    const normalizedLength = RETRIEVAL_NAME_FIELDS.has(field.field) ? 1 : field.tokens.length / Math.max(averageLength, 1);
-    const normalization = RETRIEVAL_SCORE_CONSTANTS.bm25K1
-        * (1 - RETRIEVAL_SCORE_CONSTANTS.bm25LengthNormalization
-            + RETRIEVAL_SCORE_CONSTANTS.bm25LengthNormalization * normalizedLength);
-    for (const token of context.queryTokens) {
-        const frequency = field.counts.get(token) ?? 0;
-        if (frequency === 0)
-            continue;
-        matchedTokens.push(token);
-        const documentFrequency = context.index.documentFrequency.get(token) ?? 0;
-        const inverseFrequency = Math.log(1 + (context.index.documents.length - documentFrequency + 0.5)
-            / (documentFrequency + 0.5));
-        const termScore = frequency * (RETRIEVAL_SCORE_CONSTANTS.bm25K1 + 1)
-            / (frequency + normalization);
-        score += inverseFrequency * RETRIEVAL_FIELD_WEIGHTS[field.field] * termScore
-            * queryTokenWeight(token);
-    }
-    if (matchedTokens.length === 0)
-        return null;
-    return {
-        field: field.field,
-        matchedTokens: Object.freeze(matchedTokens.slice(0, MAX_REASON_TOKENS)),
-        allMatchedTokens: Object.freeze(matchedTokens),
-        score,
-    };
-}
-function tokensEqual(left, right) {
-    return left.length === right.length && left.every((token, index) => token === right[index]);
-}
-function exactMatchAgainst(document, tokens) {
-    if (tokens.length === 0)
-        return 0;
-    if (tokensEqual(document.idTokens, tokens)) {
-        return RETRIEVAL_SCORE_CONSTANTS.exactCanonicalIdBonus;
-    }
-    if (document.aliasTokens.some((alias) => tokensEqual(alias, tokens))
-        || document.aliasActionTokens.some((alias) => tokensEqual(alias, tokens))) {
-        return RETRIEVAL_SCORE_CONSTANTS.exactAliasBonus;
-    }
-    for (const pair of document.legacyPairTokens) {
-        if (tokensEqual(pair, tokens))
-            return RETRIEVAL_SCORE_CONSTANTS.exactLegacyPairBonus;
-    }
-    for (const action of document.legacyActionTokens) {
-        if (tokensEqual(action, tokens))
-            return RETRIEVAL_SCORE_CONSTANTS.exactLegacyActionBonus;
-    }
-    return 0;
-}
-function exactMatchBonus(document, context) {
-    return Math.max(exactMatchAgainst(document, context.queryTokens), exactMatchAgainst(document, context.contentTokens));
-}
-function headAlignmentScore(actionTokens, context) {
-    const actionHead = actionTokens[0];
-    if (actionHead === undefined)
-        return 0;
-    if (actionHead === context.contentTokens[0]) {
-        return RETRIEVAL_SCORE_CONSTANTS.headVerbAlignmentBonus;
-    }
-    if (context.querySet.has(actionHead))
-        return 0;
-    return -RETRIEVAL_SCORE_CONSTANTS.headVerbMismatchPenalty;
-}
-function actionCoverageScore(document, context) {
-    let bestScore = Number.NEGATIVE_INFINITY;
-    for (const actionTokens of document.actionTokenSets) {
-        let matched = 0;
-        let unmatched = 0;
-        for (const token of actionTokens) {
-            if (context.querySet.has(token))
-                matched += queryTokenWeight(token);
-            else
-                unmatched += queryTokenWeight(token);
-        }
-        const coverage = (matched * RETRIEVAL_SCORE_CONSTANTS.matchedActionTokenBonus
-            - unmatched * RETRIEVAL_SCORE_CONSTANTS.unmatchedActionTokenPenalty)
-            / Math.max(actionTokens.length, 1);
-        bestScore = Math.max(bestScore, coverage + headAlignmentScore(actionTokens, context));
-    }
-    return Number.isFinite(bestScore) ? bestScore : 0;
-}
-function adjacencyScore(sequences, contentTokens) {
-    let score = 0;
-    for (let index = 0; index + 1 < contentTokens.length; index += 1) {
-        const first = contentTokens[index];
-        const second = contentTokens[index + 1];
-        if (first === undefined || second === undefined)
-            continue;
-        const adjacent = sequences.some((sequence) => sequence.some((token, position) => token === first && sequence[position + 1] === second));
-        if (adjacent)
-            score += RETRIEVAL_SCORE_CONSTANTS.adjacentQueryPairBonus;
-    }
-    return score;
-}
-function rounded(value, precision) {
-    const factor = 10 ** precision;
-    return Math.round(value * factor) / factor;
-}
-export function scoreDocument(document, context) {
-    const contributions = document.scoredFields
-        .map((field) => scoreField(field, context))
-        .filter((entry) => entry !== null);
-    let lexicalScore = 0;
-    for (const entry of contributions)
-        lexicalScore += entry.score;
-    const matchScore = lexicalScore
-        + exactMatchBonus(document, context)
-        + actionCoverageScore(document, context)
-        + adjacencyScore(document.sequences, context.contentTokens);
-    if (matchScore < RETRIEVAL_SCORE_CONSTANTS.minimumRelevanceScore)
-        return null;
-    const effect = document.record.behavior.effect;
-    const named = new Set(contributions
-        .filter((entry) => RETRIEVAL_COVERAGE_FIELDS.has(entry.field))
-        .flatMap((entry) => entry.allMatchedTokens));
-    const fullyNamed = context.contentTokens.length >= 2 && context.contentTokens.every((token) => named.has(token));
-    const score = matchScore
-        + (fullyNamed ? RETRIEVAL_SCORE_CONSTANTS.fullCoverageBonus : 0)
-        + (context.readIntent && effect === 'read' ? RETRIEVAL_SCORE_CONSTANTS.readIntentBonus : 0)
-        + (context.deleteIntent && effect === 'destructive' ? RETRIEVAL_SCORE_CONSTANTS.deleteIntentBonus : 0);
-    contributions.sort((left, right) => {
-        if (Math.abs(right.score - left.score) > SCORE_TIE_EPSILON)
-            return right.score - left.score;
-        return compareCanonicalCapabilityIds(left.field, right.field);
-    });
-    const matched = new Set(contributions.flatMap((entry) => entry.allMatchedTokens));
-    const coverage = matched.size / context.queryTokens.length;
-    const saturation = score / (score + RETRIEVAL_SCORE_CONSTANTS.confidenceSaturation);
-    const confidence = rounded(Math.min(1, saturation * RETRIEVAL_SCORE_CONSTANTS.confidenceSaturationWeight
-        + coverage * RETRIEVAL_SCORE_CONSTANTS.confidenceCoverageWeight), RETRIEVAL_SCORE_CONSTANTS.confidencePrecision);
-    return {
-        record: document.record,
-        score: rounded(score, RETRIEVAL_SCORE_CONSTANTS.scorePrecision),
-        confidence,
-        reasons: Object.freeze(contributions.slice(0, MAX_MATCH_REASONS).map(({ field, matchedTokens }) => ({
-            field,
-            matchedTokens,
-        }))),
-    };
-}
-export function rankCapabilityRecords(index, records, query) {
-    const queryTokens = queryCapabilityTokens(query);
-    if (queryTokens.length === 0)
-        return [];
-    const firstWord = query.toLowerCase().match(/[a-z0-9]+/u)?.[0] ?? '';
-    const allowedIds = new Set(records.map((record) => canonicalCapabilityId(index.aliasFold, String(record.id))));
-    const context = {
-        index,
-        queryTokens,
-        contentTokens: queryTokens.filter((token) => !RETRIEVAL_FUNCTION_WORDS.has(token)),
-        querySet: new Set(queryTokens),
-        readIntent: RETRIEVAL_READ_INTENT_WORDS.has(firstWord),
-        deleteIntent: RETRIEVAL_DELETE_INTENT_WORDS.has(firstWord),
-    };
-    const ranked = index.documents
-        .filter((document) => allowedIds.has(String(document.record.id)))
-        .map((document) => scoreDocument(document, context))
-        .filter((entry) => entry !== null);
-    ranked.sort((left, right) => {
-        if (Math.abs(right.score - left.score) > SCORE_TIE_EPSILON)
-            return right.score - left.score;
-        return compareCanonicalCapabilityIds(left.record.id, right.record.id);
-    });
-    return ranked;
-}
-//# sourceMappingURL=scoring.js.map

package/dist/tools/catalog/capabilities/retrieval/tokenize.d.ts

@@ -1,4 +0,0 @@
-export declare function tokenizeCapabilityText(value: string): readonly string[];
-export declare function uniqueCapabilityTokens(value: string): readonly string[];
-export declare function queryCapabilityTokens(query: string): readonly string[];
-//# sourceMappingURL=tokenize.d.ts.map

package/dist/tools/catalog/capabilities/retrieval/tokenize.js

@@ -1,47 +0,0 @@
-import { RETRIEVAL_FUNCTION_WORDS, RETRIEVAL_TOKENIZATION } from './constants.js';
-const CAMEL_CASE_BOUNDARY = /([a-z0-9])([A-Z])/g;
-const ASCII_TOKEN_PATTERN = /[a-z0-9]+/g;
-function foldInflection(token) {
-    if (RETRIEVAL_FUNCTION_WORDS.has(token))
-        return token;
-    if (token.length > 4 && token.endsWith('ies'))
-        return `${token.slice(0, -3)}y`;
-    if (token.length > 4
-        && (token.endsWith('ses') || token.endsWith('xes')
-            || token.endsWith('ches') || token.endsWith('shes'))) {
-        return token.slice(0, -2);
-    }
-    if (token.length > 3 && token.endsWith('s') && !token.endsWith('ss'))
-        return token.slice(0, -1);
-    if (token.length > 5 && token.endsWith('ing'))
-        return token.slice(0, -3);
-    if (token.length > 4 && token.endsWith('ed'))
-        return token.slice(0, -2);
-    return token;
-}
-const foldSynonym = (token) => token === 'remove' || token === 'destroy' || token === 'erase' ? 'delete' : token;
-export function tokenizeCapabilityText(value) {
-    const expanded = RETRIEVAL_TOKENIZATION.splitCamelCase
-        ? value.replace(CAMEL_CASE_BOUNDARY, '$1 $2')
-        : value;
-    const matches = expanded.toLowerCase().match(ASCII_TOKEN_PATTERN);
-    if (matches === null)
-        return [];
-    const bounded = matches.map((token) => token.slice(0, RETRIEVAL_TOKENIZATION.maxTokenLength));
-    return (RETRIEVAL_TOKENIZATION.foldInflections ? bounded.map(foldInflection) : bounded).map(foldSynonym);
-}
-export function uniqueCapabilityTokens(value) {
-    const seen = new Set();
-    const tokens = [];
-    for (const token of tokenizeCapabilityText(value)) {
-        if (seen.has(token))
-            continue;
-        seen.add(token);
-        tokens.push(token);
-    }
-    return tokens;
-}
-export function queryCapabilityTokens(query) {
-    return uniqueCapabilityTokens(query).slice(0, RETRIEVAL_TOKENIZATION.maxTokens);
-}
-//# sourceMappingURL=tokenize.js.map

package/dist/tools/catalog/capabilities/semantic/authorization.d.ts

@@ -1,20 +0,0 @@
-import { z } from 'zod';
-import { CONSENT_MODES, POLICY_SCOPES } from '../constants.js';
-export type PolicyScope = (typeof POLICY_SCOPES)[number];
-export type ConsentMode = (typeof CONSENT_MODES)[number];
-export declare function isScopeAuthorized(required: PolicyScope, granted: readonly PolicyScope[]): boolean;
-export type ConsentAcknowledgement = 'explicit' | 'elevated';
-export declare function isConsentSatisfied(policy: ConsentMode, acknowledgement: ConsentAcknowledgement | undefined): boolean;
-export declare const ConsentAcknowledgementSchema: z.ZodEnum<{
-    explicit: "explicit";
-    elevated: "elevated";
-}>;
-export declare const ConsentGrantSchema: z.ZodReadonly<z.ZodObject<{
-    capability: z.core.$ZodBranded<z.ZodString, "CapabilityId", "out">;
-    acknowledge: z.ZodEnum<{
-        explicit: "explicit";
-        elevated: "elevated";
-    }>;
-}, z.core.$strict>>;
-export type ConsentGrant = z.infer<typeof ConsentGrantSchema>;
-//# sourceMappingURL=authorization.d.ts.map

package/dist/tools/catalog/capabilities/semantic/authorization.js

@@ -1,25 +0,0 @@
-import { z } from 'zod';
-import { CapabilityIdSchema } from '../identifiers.js';
-export function isScopeAuthorized(required, granted) {
-    if (granted.includes('admin'))
-        return true;
-    return granted.includes(required);
-}
-export function isConsentSatisfied(policy, acknowledgement) {
-    switch (policy) {
-        case 'none':
-            return true;
-        case 'explicit':
-            return acknowledgement === 'explicit' || acknowledgement === 'elevated';
-        case 'elevated':
-            return acknowledgement === 'elevated';
-    }
-}
-export const ConsentAcknowledgementSchema = z.enum(['explicit', 'elevated']);
-export const ConsentGrantSchema = z
-    .strictObject({
-    capability: CapabilityIdSchema,
-    acknowledge: ConsentAcknowledgementSchema
-})
-    .readonly();
-//# sourceMappingURL=authorization.js.map

package/dist/tools/catalog/capabilities/semantic/envelope.d.ts

@@ -1,244 +0,0 @@
-import { z } from 'zod';
-import { type CapabilityId } from '../identifiers.js';
-import { JsonValueSchema, type NextCall, type SemanticError, type TaskStatus } from './errors.js';
-import type { TypedHandle } from './handles.js';
-import { type LiveStateRevisions } from './live-state-revisions.js';
-import type { CapabilityRevision, CatalogRevision, CorrelationId, IdempotencyKey, RequestId, SchemaRevision } from './ids.js';
-export declare const ValidationEvidenceSchema: z.ZodReadonly<z.ZodObject<{
-    outputSchema: z.ZodEnum<{
-        passed: "passed";
-        skipped: "skipped";
-    }>;
-    level: z.ZodOptional<z.ZodEnum<{
-        none: "none";
-        strict: "strict";
-        lenient: "lenient";
-    }>>;
-}, z.core.$strict>>;
-export type ValidationEvidence = z.infer<typeof ValidationEvidenceSchema>;
-export type Receipt = Readonly<z.infer<typeof ReceiptSchema>>;
-type SemanticData = z.infer<typeof JsonValueSchema>;
-export declare function dataDigestOf(data: SemanticData): string;
-export declare function buildSuccessReceipt(input: {
-    capabilityId: CapabilityId;
-    data: SemanticData;
-    handles?: readonly TypedHandle[];
-    correlationId?: CorrelationId;
-    requestId?: RequestId;
-    idempotencyId?: IdempotencyKey;
-    catalogRevision?: CatalogRevision;
-    capabilityRevision?: CapabilityRevision;
-    schemaRevision?: SchemaRevision;
-    changes?: readonly string[];
-    warnings?: readonly string[];
-    timingMs?: number;
-    validation?: ValidationEvidence;
-    liveRevisions?: LiveStateRevisions;
-    task?: TaskStatus;
-    nextCalls?: readonly NextCall[];
-}): Receipt;
-export declare function buildErrorReceipt(input: {
-    capabilityId: CapabilityId;
-    error: SemanticError;
-    correlationId?: CorrelationId;
-    requestId?: RequestId;
-    idempotencyId?: IdempotencyKey;
-    catalogRevision?: CatalogRevision;
-    capabilityRevision?: CapabilityRevision;
-    schemaRevision?: SchemaRevision;
-    timingMs?: number;
-    liveRevisions?: LiveStateRevisions;
-    nextCalls?: readonly NextCall[];
-}): Receipt;
-export declare const ReceiptSchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
-    status: z.ZodLiteral<"success">;
-    capabilityId: z.core.$ZodBranded<z.ZodString, "CapabilityId", "out">;
-    correlationId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CorrelationId", "out">>;
-    requestId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RequestId", "out">>;
-    idempotencyId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "IdempotencyKey", "out">>;
-    catalogRevision: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CatalogRevision", "out">>;
-    capabilityRevision: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CapabilityRevision", "out">>;
-    schemaRevision: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "SchemaRevision", "out">>;
-    handles: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
-        kind: z.ZodLiteral<"actor">;
-        ref: z.core.$ZodBranded<z.ZodString, "ActorRef", "out">;
-    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-        kind: z.ZodLiteral<"component">;
-        ref: z.core.$ZodBranded<z.ZodString, "ComponentRef", "out">;
-    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-        kind: z.ZodLiteral<"node">;
-        ref: z.core.$ZodBranded<z.ZodString, "NodeRef", "out">;
-    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-        kind: z.ZodLiteral<"object">;
-        path: z.core.$ZodBranded<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, "ObjectPath", "out">;
-    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-        kind: z.ZodLiteral<"asset">;
-        path: z.core.$ZodBranded<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, "AssetPath", "out">;
-    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-        kind: z.ZodLiteral<"class">;
-        path: z.core.$ZodBranded<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, "ClassPath", "out">;
-    }, z.core.$strict>>], "kind">>>;
-    changes: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-    warnings: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-    timingMs: z.ZodOptional<z.ZodNumber>;
-    validation: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
-        outputSchema: z.ZodEnum<{
-            passed: "passed";
-            skipped: "skipped";
-        }>;
-        level: z.ZodOptional<z.ZodEnum<{
-            none: "none";
-            strict: "strict";
-            lenient: "lenient";
-        }>>;
-    }, z.core.$strict>>>;
-    liveRevisions: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
-        selection: z.ZodNumber;
-        level: z.ZodNumber;
-        assetRegistry: z.ZodNumber;
-        package: z.ZodNumber;
-        serverInstanceId: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>>;
-    task: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
-        taskId: z.ZodString;
-        state: z.ZodEnum<{
-            completed: "completed";
-            failed: "failed";
-            queued: "queued";
-            running: "running";
-            cancelled: "cancelled";
-        }>;
-        progress: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strict>>>;
-    nextCalls: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
-        operation: z.ZodEnum<{
-            search: "search";
-            describe: "describe";
-            execute: "execute";
-            configure: "configure";
-        }>;
-        capability: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CapabilityId", "out">>;
-        params: z.ZodOptional<z.ZodJSONSchema>;
-    }, z.core.$strict>>>>;
-    dataDigest: z.ZodOptional<z.ZodString>;
-    data: z.ZodOptional<z.ZodJSONSchema>;
-}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-    status: z.ZodLiteral<"error">;
-    capabilityId: z.core.$ZodBranded<z.ZodString, "CapabilityId", "out">;
-    correlationId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CorrelationId", "out">>;
-    requestId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RequestId", "out">>;
-    idempotencyId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "IdempotencyKey", "out">>;
-    catalogRevision: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CatalogRevision", "out">>;
-    capabilityRevision: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CapabilityRevision", "out">>;
-    schemaRevision: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "SchemaRevision", "out">>;
-    timingMs: z.ZodOptional<z.ZodNumber>;
-    liveRevisions: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
-        selection: z.ZodNumber;
-        level: z.ZodNumber;
-        assetRegistry: z.ZodNumber;
-        package: z.ZodNumber;
-        serverInstanceId: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>>;
-    error: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
-        kind: z.ZodLiteral<"validation">;
-        code: z.ZodLiteral<"VALIDATION_ERROR">;
-        message: z.ZodString;
-        pointer: z.ZodOptional<z.ZodString>;
-        suggestions: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-        kind: z.ZodLiteral<"path">;
-        code: z.ZodUnion<[z.ZodLiteral<"INVALID_PATH_ROOT">, z.ZodLiteral<"PATH_TRAVERSAL">]>;
-        message: z.ZodString;
-        input: z.ZodString;
-        suggestions: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-        kind: z.ZodLiteral<"option">;
-        code: z.ZodLiteral<"UNSUPPORTED_OPTION">;
-        option: z.ZodString;
-        supported: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-        message: z.ZodString;
-        suggestions: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-        kind: z.ZodLiteral<"handle">;
-        code: z.ZodLiteral<"HANDLE_KIND_MISMATCH">;
-        expected: z.ZodString;
-        received: z.ZodString;
-        message: z.ZodString;
-        suggestions: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-        kind: z.ZodLiteral<"range">;
-        code: z.ZodUnion<[z.ZodLiteral<"OUT_OF_RANGE">, z.ZodLiteral<"WRONG_UNIT">]>;
-        field: z.ZodString;
-        message: z.ZodString;
-        suggestions: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-        kind: z.ZodLiteral<"execution">;
-        code: z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"EXECUTION_ERROR">, z.ZodLiteral<"CONNECTION_ERROR">]>, z.ZodLiteral<"UNREAL_ENGINE_ERROR">]>;
-        message: z.ZodString;
-        retryable: z.ZodBoolean;
-        handlerCode: z.ZodOptional<z.ZodString>;
-        correlationId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CorrelationId", "out">>;
-        suggestions: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-        kind: z.ZodLiteral<"capability">;
-        code: z.ZodUnion<[z.ZodLiteral<"CAPABILITY_DISABLED">, z.ZodLiteral<"CAPABILITY_UNAVAILABLE">]>;
-        message: z.ZodString;
-        retryable: z.ZodBoolean;
-        suggestions: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-        kind: z.ZodLiteral<"consent">;
-        code: z.ZodLiteral<"CONSENT_REQUIRED">;
-        message: z.ZodString;
-        scope: z.ZodString;
-        suggestions: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-        kind: z.ZodLiteral<"staleState">;
-        code: z.ZodLiteral<"STALE_STATE">;
-        message: z.ZodString;
-        currentRevision: z.ZodString;
-        expectedRevision: z.ZodString;
-        suggestions: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-        kind: z.ZodLiteral<"conflict">;
-        code: z.ZodUnion<[z.ZodLiteral<"STATE_CONFLICT">, z.ZodLiteral<"IDEMPOTENCY_CONFLICT">]>;
-        message: z.ZodString;
-        suggestions: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-        kind: z.ZodLiteral<"dispatch">;
-        code: z.ZodUnion<[z.ZodLiteral<"NOT_CONNECTED">, z.ZodLiteral<"DISPATCH_ERROR">]>;
-        message: z.ZodString;
-        retryable: z.ZodBoolean;
-        correlationId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CorrelationId", "out">>;
-        suggestions: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-        kind: z.ZodLiteral<"output">;
-        code: z.ZodUnion<[z.ZodLiteral<"OUTPUT_SCHEMA_VIOLATION">, z.ZodLiteral<"RESULT_TOO_LARGE">]>;
-        message: z.ZodString;
-        pointer: z.ZodOptional<z.ZodString>;
-        resultChars: z.ZodOptional<z.ZodNumber>;
-        suggestions: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-        kind: z.ZodLiteral<"authorization">;
-        code: z.ZodLiteral<"SCOPE_NOT_GRANTED">;
-        message: z.ZodString;
-        requiredScope: z.ZodString;
-        grantedScopes: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-        suggestions: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
-        kind: z.ZodLiteral<"unknown">;
-        code: z.ZodLiteral<"UNKNOWN_ERROR">;
-        message: z.ZodString;
-    }, z.core.$strict>>], "kind">;
-    nextCalls: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
-        operation: z.ZodEnum<{
-            search: "search";
-            describe: "describe";
-            execute: "execute";
-            configure: "configure";
-        }>;
-        capability: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CapabilityId", "out">>;
-        params: z.ZodOptional<z.ZodJSONSchema>;
-    }, z.core.$strict>>>>;
-}, z.core.$strict>>], "status">;
-export {};
-//# sourceMappingURL=envelope.d.ts.map