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

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

@@ -1,81 +0,0 @@
-import { createHash } from 'node:crypto';
-import { z } from 'zod';
-import { stableJsonStringify } from '../hashing.js';
-import { CapabilityIdSchema } from '../identifiers.js';
-import { JsonValueSchema, NextCallSchema, SemanticErrorSchema, TaskStatusSchema } from './errors.js';
-import { TypedHandleSchema } from './handles.js';
-import { LiveStateRevisionsSchema } from './live-state-revisions.js';
-import { CapabilityRevisionSchema, CatalogRevisionSchema, CorrelationIdSchema, IdempotencyKeySchema, RequestIdSchema, SchemaRevisionSchema } from './ids.js';
-import { boundArray, boundStrings, redactText } from './receipt-redaction.js';
-export const ValidationEvidenceSchema = z
-    .strictObject({
-    outputSchema: z.enum(['passed', 'skipped']),
-    level: z.enum(['strict', 'lenient', 'none']).optional()
-})
-    .readonly();
-export function dataDigestOf(data) {
-    return 'sha1:' + createHash('sha1').update(stableJsonStringify(data)).digest('hex');
-}
-export function buildSuccessReceipt(input) {
-    const { data, handles, changes, warnings, nextCalls, ...fields } = input;
-    return {
-        status: 'success',
-        ...fields,
-        handles: boundArray(handles ?? []),
-        changes: boundStrings(changes ?? []),
-        warnings: boundStrings(warnings ?? []),
-        nextCalls: boundArray(nextCalls ?? []),
-        dataDigest: dataDigestOf(data)
-    };
-}
-function redactErrorMessage(error) {
-    const suggestions = 'suggestions' in error && Array.isArray(error.suggestions)
-        ? { suggestions: boundStrings(error.suggestions) }
-        : {};
-    return SemanticErrorSchema.parse({ ...error, message: redactText(error.message), ...suggestions });
-}
-export function buildErrorReceipt(input) {
-    const { error, nextCalls, ...fields } = input;
-    return { status: 'error', ...fields, error: redactErrorMessage(error), nextCalls: boundArray(nextCalls ?? []) };
-}
-export const ReceiptSchema = z.discriminatedUnion('status', [
-    z
-        .strictObject({
-        status: z.literal('success'),
-        capabilityId: CapabilityIdSchema,
-        correlationId: CorrelationIdSchema.optional(),
-        requestId: RequestIdSchema.optional(),
-        idempotencyId: IdempotencyKeySchema.optional(),
-        catalogRevision: CatalogRevisionSchema.optional(),
-        capabilityRevision: CapabilityRevisionSchema.optional(),
-        schemaRevision: SchemaRevisionSchema.optional(),
-        handles: z.array(TypedHandleSchema).readonly(),
-        changes: z.array(z.string()).readonly(),
-        warnings: z.array(z.string()).readonly(),
-        timingMs: z.number().optional(),
-        validation: ValidationEvidenceSchema.optional(),
-        liveRevisions: LiveStateRevisionsSchema.optional(),
-        task: TaskStatusSchema.optional(),
-        nextCalls: z.array(NextCallSchema).readonly(),
-        dataDigest: z.string().optional(),
-        data: JsonValueSchema.optional()
-    })
-        .readonly(),
-    z
-        .strictObject({
-        status: z.literal('error'),
-        capabilityId: CapabilityIdSchema,
-        correlationId: CorrelationIdSchema.optional(),
-        requestId: RequestIdSchema.optional(),
-        idempotencyId: IdempotencyKeySchema.optional(),
-        catalogRevision: CatalogRevisionSchema.optional(),
-        capabilityRevision: CapabilityRevisionSchema.optional(),
-        schemaRevision: SchemaRevisionSchema.optional(),
-        timingMs: z.number().optional(),
-        liveRevisions: LiveStateRevisionsSchema.optional(),
-        error: SemanticErrorSchema,
-        nextCalls: z.array(NextCallSchema).readonly()
-    })
-        .readonly()
-]);
-//# sourceMappingURL=envelope.js.map

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

@@ -1,122 +0,0 @@
-import { z } from 'zod';
-export declare const JsonValueSchema: z.ZodJSONSchema;
-export declare const SemanticErrorSchema: 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">;
-export type SemanticErrorCode = z.infer<typeof SemanticErrorSchema>['code'];
-export type SemanticError = z.infer<typeof SemanticErrorSchema>;
-export declare class SemanticBoundaryError extends Error {
-    readonly semanticError: SemanticError;
-    constructor(semanticError: SemanticError);
-}
-export type TaskStatus = z.infer<typeof TaskStatusSchema>;
-export declare const TaskStatusSchema: 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>>;
-export type NextCall = z.infer<typeof NextCallSchema>;
-export declare const NextCallSchema: 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>>;
-//# sourceMappingURL=errors.d.ts.map

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

@@ -1,163 +0,0 @@
-import { z } from 'zod';
-import { CapabilityIdSchema } from '../identifiers.js';
-import { CorrelationIdSchema } from './ids.js';
-export const JsonValueSchema = z.json();
-export const SemanticErrorSchema = z.discriminatedUnion('kind', [
-    z
-        .strictObject({
-        kind: z.literal('validation'),
-        code: z.literal('VALIDATION_ERROR'),
-        message: z.string(),
-        pointer: z.string().optional(),
-        suggestions: z.array(z.string()).readonly().optional()
-    })
-        .readonly(),
-    z
-        .strictObject({
-        kind: z.literal('path'),
-        code: z.literal('INVALID_PATH_ROOT').or(z.literal('PATH_TRAVERSAL')),
-        message: z.string(),
-        input: z.string(),
-        suggestions: z.array(z.string()).readonly().optional()
-    })
-        .readonly(),
-    z
-        .strictObject({
-        kind: z.literal('option'),
-        code: z.literal('UNSUPPORTED_OPTION'),
-        option: z.string(),
-        supported: z.array(z.string()).readonly(),
-        message: z.string(),
-        suggestions: z.array(z.string()).readonly().optional()
-    })
-        .readonly(),
-    z
-        .strictObject({
-        kind: z.literal('handle'),
-        code: z.literal('HANDLE_KIND_MISMATCH'),
-        expected: z.string(),
-        received: z.string(),
-        message: z.string(),
-        suggestions: z.array(z.string()).readonly().optional()
-    })
-        .readonly(),
-    z
-        .strictObject({
-        kind: z.literal('range'),
-        code: z.literal('OUT_OF_RANGE').or(z.literal('WRONG_UNIT')),
-        field: z.string(),
-        message: z.string(),
-        suggestions: z.array(z.string()).readonly().optional()
-    })
-        .readonly(),
-    z
-        .strictObject({
-        kind: z.literal('execution'),
-        code: z
-            .literal('EXECUTION_ERROR')
-            .or(z.literal('CONNECTION_ERROR'))
-            .or(z.literal('UNREAL_ENGINE_ERROR')),
-        message: z.string(),
-        retryable: z.boolean(),
-        handlerCode: z.string().regex(/^[A-Z][A-Z0-9_]{0,63}$/).optional(),
-        correlationId: CorrelationIdSchema.optional(),
-        suggestions: z.array(z.string()).readonly().optional()
-    })
-        .readonly(),
-    z
-        .strictObject({
-        kind: z.literal('capability'),
-        code: z.literal('CAPABILITY_DISABLED').or(z.literal('CAPABILITY_UNAVAILABLE')),
-        message: z.string(),
-        retryable: z.boolean(),
-        suggestions: z.array(z.string()).readonly().optional()
-    })
-        .readonly(),
-    z
-        .strictObject({
-        kind: z.literal('consent'),
-        code: z.literal('CONSENT_REQUIRED'),
-        message: z.string(),
-        scope: z.string().min(1).max(64),
-        suggestions: z.array(z.string()).readonly().optional()
-    })
-        .readonly(),
-    z
-        .strictObject({
-        kind: z.literal('staleState'),
-        code: z.literal('STALE_STATE'),
-        message: z.string(),
-        currentRevision: z.string().min(1).max(128),
-        expectedRevision: z.string().min(1).max(128),
-        suggestions: z.array(z.string()).readonly().optional()
-    })
-        .readonly(),
-    z
-        .strictObject({
-        kind: z.literal('conflict'),
-        code: z.literal('STATE_CONFLICT').or(z.literal('IDEMPOTENCY_CONFLICT')),
-        message: z.string(),
-        suggestions: z.array(z.string()).readonly().optional()
-    })
-        .readonly(),
-    z
-        .strictObject({
-        kind: z.literal('dispatch'),
-        code: z.literal('NOT_CONNECTED').or(z.literal('DISPATCH_ERROR')),
-        message: z.string(),
-        retryable: z.boolean(),
-        correlationId: CorrelationIdSchema.optional(),
-        suggestions: z.array(z.string()).readonly().optional()
-    })
-        .readonly(),
-    z
-        .strictObject({
-        kind: z.literal('output'),
-        code: z.literal('OUTPUT_SCHEMA_VIOLATION').or(z.literal('RESULT_TOO_LARGE')),
-        message: z.string(),
-        pointer: z.string().optional(),
-        resultChars: z.number().optional(),
-        suggestions: z.array(z.string()).readonly().optional()
-    })
-        .readonly(),
-    z
-        .strictObject({
-        kind: z.literal('authorization'),
-        code: z.literal('SCOPE_NOT_GRANTED'),
-        message: z.string(),
-        requiredScope: z.string().min(1).max(32),
-        grantedScopes: z.array(z.string()).readonly(),
-        suggestions: z.array(z.string()).readonly().optional()
-    })
-        .readonly(),
-    z
-        .strictObject({
-        kind: z.literal('unknown'),
-        code: z.literal('UNKNOWN_ERROR'),
-        message: z.string()
-    })
-        .readonly()
-]);
-export class SemanticBoundaryError extends Error {
-    semanticError;
-    constructor(semanticError) {
-        super(semanticError.message);
-        this.name = 'SemanticBoundaryError';
-        this.semanticError = semanticError;
-    }
-}
-export const TaskStatusSchema = z
-    .strictObject({
-    taskId: z.string().min(1),
-    state: z.enum(['queued', 'running', 'completed', 'failed', 'cancelled']),
-    progress: z.number().min(0).max(1).optional()
-})
-    .readonly();
-export const NextCallSchema = z
-    .strictObject({
-    operation: z.enum(['search', 'describe', 'execute', 'configure']),
-    capability: CapabilityIdSchema.optional(),
-    params: JsonValueSchema.optional()
-})
-    .readonly();
-//# sourceMappingURL=errors.js.map

package/dist/tools/catalog/capabilities/semantic/execution-options.d.ts

@@ -1,23 +0,0 @@
-import { z } from 'zod';
-export declare const EXECUTION_OPTION_KEYS: readonly ["idempotencyKey", "expectedCatalogRevision", "expectedRevisions", "timeoutMs"];
-export type ExecutionOptionKey = (typeof EXECUTION_OPTION_KEYS)[number];
-export declare const LIVE_STATE_REVISION_KEYS: readonly ["selection", "level", "assetRegistry", "package"];
-export declare const ExpectedRevisionsSchema: z.ZodReadonly<z.ZodObject<{
-    selection: z.ZodOptional<z.ZodNumber>;
-    level: z.ZodOptional<z.ZodNumber>;
-    assetRegistry: z.ZodOptional<z.ZodNumber>;
-    package: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strict>>;
-export type ExpectedRevisions = z.infer<typeof ExpectedRevisionsSchema>;
-export declare const ExecutionOptionsSchema: z.ZodReadonly<z.ZodObject<{
-    idempotencyKey: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "IdempotencyKey", "out">>;
-    expectedCatalogRevision: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CatalogRevision", "out">>;
-    expectedRevisions: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
-        selection: z.ZodOptional<z.ZodNumber>;
-        level: z.ZodOptional<z.ZodNumber>;
-        assetRegistry: z.ZodOptional<z.ZodNumber>;
-        package: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strict>>>;
-    timeoutMs: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strict>>;
-//# sourceMappingURL=execution-options.d.ts.map

package/dist/tools/catalog/capabilities/semantic/execution-options.js

@@ -1,29 +0,0 @@
-import { z } from 'zod';
-import { CatalogRevisionSchema, IdempotencyKeySchema } from './ids.js';
-export const EXECUTION_OPTION_KEYS = [
-    'idempotencyKey',
-    'expectedCatalogRevision',
-    'expectedRevisions',
-    'timeoutMs'
-];
-const MAX_TIMEOUT_MS = 600_000;
-export const LIVE_STATE_REVISION_KEYS = [
-    'selection',
-    'level',
-    'assetRegistry',
-    'package'
-];
-export const ExpectedRevisionsSchema = z.strictObject({
-    selection: z.number().int().min(1).optional(),
-    level: z.number().int().min(1).optional(),
-    assetRegistry: z.number().int().min(1).optional(),
-    package: z.number().int().min(1).optional()
-}).readonly();
-const ExecutionOptionsShape = {
-    idempotencyKey: IdempotencyKeySchema.optional(),
-    expectedCatalogRevision: CatalogRevisionSchema.optional(),
-    expectedRevisions: ExpectedRevisionsSchema.optional(),
-    timeoutMs: z.number().int().positive().max(MAX_TIMEOUT_MS).optional()
-};
-export const ExecutionOptionsSchema = z.strictObject(ExecutionOptionsShape).readonly();
-//# sourceMappingURL=execution-options.js.map

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

@@ -1,33 +0,0 @@
-import { z } from 'zod';
-export declare const ActorRefSchema: z.core.$ZodBranded<z.ZodString, "ActorRef", "out">;
-export type ActorRef = z.infer<typeof ActorRefSchema>;
-export declare const ComponentRefSchema: z.core.$ZodBranded<z.ZodString, "ComponentRef", "out">;
-export type ComponentRef = z.infer<typeof ComponentRefSchema>;
-export declare const NodeRefSchema: z.core.$ZodBranded<z.ZodString, "NodeRef", "out">;
-export type NodeRef = z.infer<typeof NodeRefSchema>;
-export declare const TypedHandleSchema: 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">;
-export type TypedHandle = Readonly<z.infer<typeof TypedHandleSchema>>;
-export type HandleKind = z.infer<typeof TypedHandleSchema>['kind'];
-export declare function expectHandleKind<K extends HandleKind>(handle: TypedHandle, expected: K): Extract<TypedHandle, {
-    kind: K;
-}>;
-export declare function expectHandleKind(handle: TypedHandle, expected: HandleKind): TypedHandle;
-//# sourceMappingURL=handles.d.ts.map

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

@@ -1,28 +0,0 @@
-import { z } from 'zod';
-import { SemanticBoundaryError } from './errors.js';
-import { AssetPathSchema, ClassPathSchema, ObjectPathSchema } from './paths.js';
-export const ActorRefSchema = z.string().min(1).max(512).brand();
-export const ComponentRefSchema = z.string().min(1).max(512).brand();
-export const NodeRefSchema = z.string().min(1).max(512).brand();
-export const TypedHandleSchema = z.discriminatedUnion('kind', [
-    z.strictObject({ kind: z.literal('actor'), ref: ActorRefSchema }).readonly(),
-    z.strictObject({ kind: z.literal('component'), ref: ComponentRefSchema }).readonly(),
-    z.strictObject({ kind: z.literal('node'), ref: NodeRefSchema }).readonly(),
-    z.strictObject({ kind: z.literal('object'), path: ObjectPathSchema }).readonly(),
-    z.strictObject({ kind: z.literal('asset'), path: AssetPathSchema }).readonly(),
-    z.strictObject({ kind: z.literal('class'), path: ClassPathSchema }).readonly()
-]);
-export function expectHandleKind(handle, expected) {
-    if (handle.kind !== expected) {
-        const semanticError = {
-            kind: 'handle',
-            code: 'HANDLE_KIND_MISMATCH',
-            expected,
-            received: handle.kind,
-            message: `Expected handle kind '${expected}' but received '${handle.kind}'`
-        };
-        throw new SemanticBoundaryError(semanticError);
-    }
-    return handle;
-}
-//# sourceMappingURL=handles.js.map

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

@@ -1,14 +0,0 @@
-import { z } from 'zod';
-export declare const IdempotencyKeySchema: z.core.$ZodBranded<z.ZodString, "IdempotencyKey", "out">;
-export type IdempotencyKey = z.infer<typeof IdempotencyKeySchema>;
-export declare const CorrelationIdSchema: z.core.$ZodBranded<z.ZodString, "CorrelationId", "out">;
-export type CorrelationId = z.infer<typeof CorrelationIdSchema>;
-export declare const CatalogRevisionSchema: z.core.$ZodBranded<z.ZodString, "CatalogRevision", "out">;
-export type CatalogRevision = z.infer<typeof CatalogRevisionSchema>;
-export declare const CapabilityRevisionSchema: z.core.$ZodBranded<z.ZodString, "CapabilityRevision", "out">;
-export type CapabilityRevision = z.infer<typeof CapabilityRevisionSchema>;
-export declare const SchemaRevisionSchema: z.core.$ZodBranded<z.ZodString, "SchemaRevision", "out">;
-export type SchemaRevision = z.infer<typeof SchemaRevisionSchema>;
-export declare const RequestIdSchema: z.core.$ZodBranded<z.ZodString, "RequestId", "out">;
-export type RequestId = z.infer<typeof RequestIdSchema>;
-//# sourceMappingURL=ids.d.ts.map

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

@@ -1,36 +0,0 @@
-import { z } from 'zod';
-export const IdempotencyKeySchema = z
-    .string()
-    .min(1)
-    .max(128)
-    .brand();
-export const CorrelationIdSchema = z
-    .string()
-    .min(1)
-    .max(128)
-    .brand();
-const HEX_REVISION = /^[0-9a-f]{1,64}$/;
-export const CatalogRevisionSchema = z
-    .string()
-    .min(1)
-    .max(64)
-    .regex(HEX_REVISION)
-    .brand();
-export const CapabilityRevisionSchema = z
-    .string()
-    .min(1)
-    .max(64)
-    .regex(HEX_REVISION)
-    .brand();
-export const SchemaRevisionSchema = z
-    .string()
-    .min(1)
-    .max(64)
-    .regex(HEX_REVISION)
-    .brand();
-export const RequestIdSchema = z
-    .string()
-    .min(1)
-    .max(256)
-    .brand();
-//# sourceMappingURL=ids.js.map

package/dist/tools/catalog/capabilities/semantic/live-state-revisions.d.ts

@@ -1,11 +0,0 @@
-import { z } from 'zod';
-export declare const LiveStateRevisionsSchema: z.ZodReadonly<z.ZodObject<{
-    selection: z.ZodNumber;
-    level: z.ZodNumber;
-    assetRegistry: z.ZodNumber;
-    package: z.ZodNumber;
-    serverInstanceId: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>>;
-export type LiveStateRevisions = z.infer<typeof LiveStateRevisionsSchema>;
-export declare function liveStateRevisionsFromEnvelope(value: unknown): LiveStateRevisions | undefined;
-//# sourceMappingURL=live-state-revisions.d.ts.map

package/dist/tools/catalog/capabilities/semantic/live-state-revisions.js

@@ -1,18 +0,0 @@
-import { z } from 'zod';
-const RevisionCounterSchema = z.number().int().min(1);
-export const LiveStateRevisionsSchema = z
-    .strictObject({
-    selection: RevisionCounterSchema,
-    level: RevisionCounterSchema,
-    assetRegistry: RevisionCounterSchema,
-    package: RevisionCounterSchema,
-    serverInstanceId: z.string().min(1).optional()
-})
-    .readonly();
-export function liveStateRevisionsFromEnvelope(value) {
-    if (typeof value !== 'object' || value === null || Array.isArray(value))
-        return undefined;
-    const parsed = LiveStateRevisionsSchema.safeParse(Reflect.get(value, 'liveRevisions'));
-    return parsed.success ? parsed.data : undefined;
-}
-//# sourceMappingURL=live-state-revisions.js.map

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

@@ -1,9 +0,0 @@
-import { z } from 'zod';
-export declare const AssetPathSchema: z.core.$ZodBranded<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, "AssetPath", "out">;
-export type AssetPath = z.infer<typeof AssetPathSchema>;
-export declare const ObjectPathSchema: z.core.$ZodBranded<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, "ObjectPath", "out">;
-export type ObjectPath = z.infer<typeof ObjectPathSchema>;
-export declare const ClassPathSchema: z.core.$ZodBranded<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, "ClassPath", "out">;
-export type ClassPath = z.infer<typeof ClassPathSchema>;
-export declare function parseAssetPath(input: unknown): AssetPath;
-//# sourceMappingURL=paths.d.ts.map