@mcp-web/decompose-zod-schema 0.1.0

package/dist/cli.js

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+import { readFile, writeFile } from 'node:fs/promises';
+import { Command } from 'commander';
+import { z } from 'zod';
+import { decomposeSchema } from './decompose.js';
+import { estimateTokensByJsonSchema } from './utils.js';
+function log(message, verbose) {
+    if (verbose) {
+        console.log(`[INFO] ${message}`);
+    }
+}
+async function extractSchemaFromFile(filePath, schemaName) {
+    try {
+        // Read the TypeScript file
+        await readFile(filePath, 'utf-8');
+        // This is a simplified approach - in a real implementation, you might want to:
+        // 1. Use a TypeScript parser/AST
+        // 2. Dynamically import and evaluate the module
+        // 3. Support more complex schema definitions
+        // For now, we'll create a simple example schema that users can modify
+        const exampleSchema = z.object({
+            user: z.object({
+                id: z.string(),
+                name: z.string(),
+                email: z.string().email(),
+                age: z.number(),
+                profile: z.object({
+                    bio: z.string(),
+                    avatar: z.string().url().optional(),
+                    preferences: z.object({
+                        theme: z.enum(['light', 'dark', 'auto']),
+                        language: z.enum([
+                            'en',
+                            'es',
+                            'fr',
+                            'de',
+                            'it',
+                            'pt',
+                            'ru',
+                            'ja',
+                            'ko',
+                            'zh',
+                        ]),
+                        notifications: z.boolean(),
+                        newsletter: z.boolean(),
+                    }),
+                }),
+            }),
+            settings: z.object({
+                privacy: z.enum(['public', 'private', 'friends']),
+                twoFactor: z.boolean(),
+                apiKeys: z.array(z.string()),
+            }),
+            metadata: z.object({
+                createdAt: z.date(),
+                updatedAt: z.date(),
+                version: z.number(),
+                tags: z.array(z.string()),
+                categories: z.enum(Array.from({ length: 150 }, (_, i) => `category-${i}`)),
+            }),
+        });
+        // Log warning about simplified extraction
+        console.warn(`Warning: Using example schema. In a real implementation, this would parse '${schemaName}' from '${filePath}'.`);
+        console.warn('To use your own schema, modify the CLI to properly import and extract your schema definition.');
+        return exampleSchema;
+    }
+    catch (error) {
+        throw new Error(`Failed to extract schema from ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function main() {
+    const program = new Command();
+    program
+        .name('decompose-zod-schema')
+        .description('Utility for decomposing large Zod schemas into smaller, manageable sub-schemas')
+        .version('0.1.0')
+        .requiredOption('-i, --input <file>', 'Input TypeScript file containing schema definition')
+        .option('-o, --output <file>', 'Output JSON file for decomposed schemas')
+        .requiredOption('-s, --schema <name>', 'Name of the schema variable to decompose')
+        .option('-t, --tokens <number>', 'Maximum tokens per decomposed schema', '2000')
+        .option('-e, --enum-size <number>', 'Maximum enum size before splitting', '200')
+        .option('-v, --verbose', 'Verbose output', false)
+        .addHelpText('after', `
+Examples:
+  $ decompose-zod-schema -i schema.ts -s userSchema -o decomposed.json
+  $ decompose-zod-schema -i schema.ts -s configSchema -t 1000 -e 100 -v`);
+    program.parse();
+    const options = program.opts();
+    // Convert string options to numbers
+    options.tokens = parseInt(options.tokens, 10);
+    options.enumSize = parseInt(options.enumSize, 10);
+    try {
+        log(`Extracting schema '${options.schema}' from '${options.input}'`, options.verbose);
+        const schema = await extractSchemaFromFile(options.input, options.schema);
+        log('Estimating token count for original schema', options.verbose);
+        const originalTokens = estimateTokensByJsonSchema(schema);
+        log(`Original schema estimated tokens: ${originalTokens}`, options.verbose);
+        if (originalTokens <= options.tokens) {
+            log('Schema is already within token limits, no decomposition needed', options.verbose);
+            const result = {
+                originalTokens,
+                maxTokensPerSchema: options.tokens,
+                needsDecomposition: false,
+                decomposedSchemas: [
+                    {
+                        name: 'complete',
+                        schema: JSON.parse(JSON.stringify(schema._def)),
+                        targetPaths: ['*'],
+                        estimatedTokens: originalTokens,
+                    },
+                ],
+            };
+            if (options.output) {
+                await writeFile(options.output, JSON.stringify(result, null, 2), 'utf-8');
+                log(`Results written to ${options.output}`, options.verbose);
+            }
+            else {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            return;
+        }
+        log('Decomposing schema', options.verbose);
+        const decomposed = decomposeSchema(schema, {
+            maxTokensPerSchema: options.tokens,
+            maxOptionsPerEnum: options.enumSize,
+        });
+        log(`Created ${decomposed.length} decomposed schemas`, options.verbose);
+        const result = {
+            originalTokens,
+            maxTokensPerSchema: options.tokens,
+            maxOptionsPerEnum: options.enumSize,
+            needsDecomposition: true,
+            decomposedSchemas: decomposed.map((item) => ({
+                name: item.name,
+                schema: JSON.parse(JSON.stringify(item.schema._def)),
+                targetPaths: item.targetPaths,
+                estimatedTokens: estimateTokensByJsonSchema(item.schema),
+            })),
+        };
+        // Summary
+        log('\\nDecomposition Summary:', options.verbose);
+        log(`  Original tokens: ${originalTokens}`, options.verbose);
+        log(`  Decomposed into: ${decomposed.length} schemas`, options.verbose);
+        decomposed.forEach((item, index) => {
+            const tokens = estimateTokensByJsonSchema(item.schema);
+            log(`  Schema ${index + 1} (${item.name}): ${tokens} tokens, ${item.targetPaths.length} paths`, options.verbose);
+        });
+        if (options.output) {
+            await writeFile(options.output, JSON.stringify(result, null, 2), 'utf-8');
+            log(`Results written to ${options.output}`, options.verbose);
+        }
+        else {
+            console.log(JSON.stringify(result, null, 2));
+        }
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+}
+// Run the CLI if this file is being executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main();
+}

package/dist/decompose.d.ts

@@ -0,0 +1,41 @@
+import { ZodObject, type ZodType } from 'zod';
+import type { DecomposedSchema, DecompositionOptions, SplitPlan } from './types.js';
+/**
+ * Decomposes a Zod schema into smaller schemas based on a split plan or options.
+ *
+ * This function supports two modes:
+ * 1. **Manual decomposition**: Pass a SplitPlan array to control exactly how the schema is split
+ * 2. **Automatic decomposition**: Pass options to automatically suggest splits based on size
+ *
+ * @param schema - The Zod object schema to decompose
+ * @param planOrOptions - Either a SplitPlan for manual decomposition or DecompositionOptions for automatic
+ * @returns Array of decomposed schemas with their target paths
+ *
+ * @example Manual decomposition with SplitPlan
+ * ```typescript
+ * const decomposed = decomposeSchema(GameStateSchema, [
+ *   'board',
+ *   ['currentPlayer', 'turn'],
+ *   'settings',
+ * ]);
+ * ```
+ *
+ * @example Automatic decomposition with options
+ * ```typescript
+ * const decomposed = decomposeSchema(LargeSchema, {
+ *   maxTokensPerSchema: 2000,
+ *   maxOptionsPerEnum: 200,
+ * });
+ * ```
+ */
+export declare function decomposeSchema(schema: ZodObject<Record<string, ZodType>>, planOrOptions: SplitPlan | DecompositionOptions): DecomposedSchema[];
+/**
+ * Manually decompose a schema using a predefined split plan.
+ * This function takes a schema and a split plan that defines exactly how to split it.
+ *
+ * @param schema - The Zod schema to decompose
+ * @param plan - Array of path specifications defining how to split the schema
+ * @returns Array of decomposed schemas with their target paths
+ */
+export declare function decomposeSchemaWithPlan(schema: ZodObject<Record<string, ZodType>>, plan: SplitPlan): DecomposedSchema[];
+//# sourceMappingURL=decompose.d.ts.map

package/dist/decompose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decompose.d.ts","sourceRoot":"","sources":["../src/decompose.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,SAAS,EAA6B,KAAK,OAAO,EAAK,MAAM,KAAK,CAAC;AAE/F,OAAO,KAAK,EAAE,gBAAgB,EAAE,oBAAoB,EAAoB,SAAS,EAAE,MAAM,YAAY,CAAC;AAStG;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAC1C,aAAa,EAAE,SAAS,GAAG,oBAAoB,GAC9C,gBAAgB,EAAE,CAepB;AAGD;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAC1C,IAAI,EAAE,SAAS,GACd,gBAAgB,EAAE,CAuRpB"}

package/dist/decompose.js

@@ -0,0 +1,383 @@
+import { ZodArray, ZodEnum, ZodObject, ZodRecord, z } from 'zod';
+import { suggestDecompositionPlan } from './split-suggestions.js';
+import { evenChunk, extractSchemaForPaths, getSchemaAtPath, parseEnumSplit, } from './utils.js';
+import { validatePlan } from './validate.js';
+/**
+ * Decomposes a Zod schema into smaller schemas based on a split plan or options.
+ *
+ * This function supports two modes:
+ * 1. **Manual decomposition**: Pass a SplitPlan array to control exactly how the schema is split
+ * 2. **Automatic decomposition**: Pass options to automatically suggest splits based on size
+ *
+ * @param schema - The Zod object schema to decompose
+ * @param planOrOptions - Either a SplitPlan for manual decomposition or DecompositionOptions for automatic
+ * @returns Array of decomposed schemas with their target paths
+ *
+ * @example Manual decomposition with SplitPlan
+ * ```typescript
+ * const decomposed = decomposeSchema(GameStateSchema, [
+ *   'board',
+ *   ['currentPlayer', 'turn'],
+ *   'settings',
+ * ]);
+ * ```
+ *
+ * @example Automatic decomposition with options
+ * ```typescript
+ * const decomposed = decomposeSchema(LargeSchema, {
+ *   maxTokensPerSchema: 2000,
+ *   maxOptionsPerEnum: 200,
+ * });
+ * ```
+ */
+export function decomposeSchema(schema, planOrOptions) {
+    // Check if it's a split plan (array) or options (object with specific properties)
+    if (Array.isArray(planOrOptions)) {
+        // Manual decomposition with split plan
+        return decomposeSchemaWithPlan(schema, planOrOptions);
+    }
+    else {
+        // Automatic decomposition with size-based suggestions
+        // Provide defaults for missing options
+        const sizeBasedOptions = {
+            maxTokensPerSchema: planOrOptions.maxTokensPerSchema ?? 2000,
+            maxOptionsPerEnum: planOrOptions.maxOptionsPerEnum ?? 200,
+        };
+        const suggestedPlan = suggestDecompositionPlan(schema, sizeBasedOptions);
+        return decomposeSchemaWithPlan(schema, suggestedPlan);
+    }
+}
+/**
+ * Manually decompose a schema using a predefined split plan.
+ * This function takes a schema and a split plan that defines exactly how to split it.
+ *
+ * @param schema - The Zod schema to decompose
+ * @param plan - Array of path specifications defining how to split the schema
+ * @returns Array of decomposed schemas with their target paths
+ */
+export function decomposeSchemaWithPlan(schema, plan) {
+    // Validate the split plan first
+    const validationErrors = validatePlan(plan, schema);
+    if (validationErrors.length > 0) {
+        throw new Error(`Invalid split plan: ${validationErrors.join(', ')}`);
+    }
+    const result = [];
+    const processedPaths = new Set();
+    const processedItems = new Set();
+    const parsedSplits = plan.map(split => ({
+        original: split,
+        ...parseArrayNotation(split)
+    }));
+    // Group splits by type
+    const arrayGroups = new Map();
+    const recordGroups = new Map();
+    const regularSplits = [];
+    parsedSplits.forEach(({ original, path, isArrayElement }) => {
+        const parsed = parseEnumSplit(original);
+        if (parsed.isArraySplit) {
+            // Handle nested array splits like 'views[].tracks.top[]'
+            if (original.includes('[].') && original.match(/^(.+)\[\]\.(.+)\[\]$/)) {
+                // This is a nested array split - handle it specially
+                if (!arrayGroups.has('nested'))
+                    arrayGroups.set('nested', []);
+                arrayGroups.get('nested')?.push(original);
+            }
+            else {
+                // Regular array split like 'views[]'
+                if (!arrayGroups.has(parsed.path))
+                    arrayGroups.set(parsed.path, []);
+                arrayGroups.get(parsed.path)?.push(original);
+            }
+        }
+        else if (parsed.isRecordSplit) {
+            if (!recordGroups.has(parsed.path))
+                recordGroups.set(parsed.path, []);
+            recordGroups.get(parsed.path)?.push(original);
+        }
+        else if (isArrayElement) {
+            if (!arrayGroups.has(path))
+                arrayGroups.set(path, []);
+            arrayGroups.get(path)?.push(original);
+        }
+        else {
+            regularSplits.push(original);
+        }
+    });
+    // Handle array splits
+    arrayGroups.forEach((splits, arrayPath) => {
+        if (arrayPath === 'nested') {
+            // Handle nested array splits like 'views[].tracks.top[]'
+            splits.forEach(splitPath => {
+                const nestedMatch = splitPath.match(/^(.+)\[\]\.(.+)\[\]$/);
+                if (nestedMatch) {
+                    const [, basePath, subPath] = nestedMatch;
+                    // Get the base array schema (e.g., 'views')
+                    const baseArraySchema = getSchemaAtPath(schema, basePath);
+                    if (!(baseArraySchema instanceof ZodArray)) {
+                        console.warn(`Expected array at path: ${basePath}`);
+                        return;
+                    }
+                    // Get the element schema and navigate to the sub-array
+                    const elementSchema = baseArraySchema.element;
+                    if (!(elementSchema instanceof ZodObject)) {
+                        console.warn(`Expected object element in array at path: ${basePath}`);
+                        return;
+                    }
+                    // Get the sub-array schema (e.g., 'tracks.top')
+                    let subArraySchema = getSchemaAtPath(elementSchema, subPath);
+                    // Unwrap optional schemas
+                    if (subArraySchema && typeof subArraySchema === 'object' && 'unwrap' in subArraySchema) {
+                        subArraySchema = subArraySchema.unwrap();
+                    }
+                    if (!(subArraySchema instanceof ZodArray)) {
+                        console.warn(`Expected array at nested path: ${basePath}[].${subPath}`);
+                        return;
+                    }
+                    // Create the schema for the nested array element
+                    const nestedElementSchema = createArrayElementSchema(subArraySchema);
+                    result.push({
+                        name: `${basePath.replace(/\./g, '-')}-${subPath.replace(/\./g, '-')}-item`,
+                        schema: nestedElementSchema,
+                        targetPaths: [splitPath]
+                    });
+                }
+            });
+        }
+        else {
+            // Handle regular array splits
+            const arraySchema = getSchemaAtPath(schema, arrayPath);
+            if (!(arraySchema instanceof ZodArray)) {
+                console.warn(`Expected array at path: ${arrayPath}`);
+                return;
+            }
+            splits.forEach(splitPath => {
+                const parsed = parseEnumSplit(splitPath);
+                if (parsed.isArraySplit) {
+                    const elementSchema = createArrayElementSchema(arraySchema);
+                    result.push({
+                        name: `${arrayPath.replace(/\./g, '-')}-item`,
+                        schema: elementSchema,
+                        targetPaths: [splitPath]
+                    });
+                }
+                else {
+                    // Handle legacy array notation with exclusions
+                    const { excludedSubArrays } = parseArrayNotation(splitPath);
+                    const elementSchema = createArrayElementSchema(arraySchema, excludedSubArrays);
+                    result.push({
+                        name: `${arrayPath.replace(/\./g, '-')}-item`,
+                        schema: elementSchema,
+                        targetPaths: [splitPath]
+                    });
+                }
+            });
+        }
+    });
+    // Handle record splits
+    recordGroups.forEach((splits, recordPath) => {
+        const recordSchema = getSchemaAtPath(schema, recordPath);
+        if (!(recordSchema instanceof ZodRecord)) {
+            console.warn(`Expected record at path: ${recordPath}`);
+            return;
+        }
+        splits.forEach(splitPath => {
+            const elementSchema = createRecordElementSchema(recordSchema);
+            result.push({
+                name: `${recordPath.replace(/\./g, '-')}-entry`,
+                schema: elementSchema,
+                targetPaths: [splitPath]
+            });
+        });
+    });
+    for (const item of plan) {
+        const parsed = parseEnumSplit(item);
+        // Skip if we've already processed this exact item
+        if (processedItems.has(item)) {
+            continue;
+        }
+        // Skip array and record splits as they're handled above
+        if (parsed.isArraySplit || parsed.isRecordSplit) {
+            processedItems.add(item);
+            continue;
+        }
+        const schemaAtPath = getSchemaAtPath(schema, parsed.path);
+        if (!schemaAtPath) {
+            continue; // Skip invalid paths (already validated above)
+        }
+        // Handle enum splitting
+        if (schemaAtPath instanceof ZodEnum && parsed.chunkSize) {
+            const enumOptions = schemaAtPath.options;
+            const chunks = evenChunk(enumOptions, parsed.chunkSize);
+            chunks.forEach((chunk, index) => {
+                const chunkName = chunks.length > 1 ? `${parsed.path}-${index + 1}` : parsed.path;
+                const startIndex = index * Math.ceil(enumOptions.length / chunks.length);
+                const endIndex = Math.min(startIndex + chunk.length, enumOptions.length);
+                const slicePath = `${parsed.path}[${startIndex}:${endIndex}]`;
+                // Create schema with just this enum chunk
+                const chunkSchema = z.object({
+                    [parsed.path.split('.').pop() || parsed.path]: z.enum(chunk),
+                });
+                result.push({
+                    name: chunkName,
+                    schema: chunkSchema,
+                    targetPaths: [slicePath],
+                });
+            });
+            processedItems.add(item);
+        }
+        // Handle slice notation (including shorthand)
+        else if (schemaAtPath instanceof ZodEnum && parsed.start !== undefined) {
+            const enumOptions = schemaAtPath.options;
+            const end = parsed.end !== undefined ? parsed.end : enumOptions.length;
+            const slicedOptions = enumOptions.slice(parsed.start, end);
+            if (slicedOptions.length > 0) {
+                const sliceSchema = z.object({
+                    [parsed.path.split('.').pop() || parsed.path]: z.enum(slicedOptions),
+                });
+                // Generate appropriate name for the slice
+                const sliceName = parsed.end !== undefined
+                    ? `${parsed.path}-${parsed.start}-${parsed.end}`
+                    : `${parsed.path}-${parsed.start}-end`;
+                result.push({
+                    name: sliceName,
+                    schema: sliceSchema,
+                    targetPaths: [item],
+                });
+            }
+            processedItems.add(item);
+        }
+        // Handle regular path extraction
+        else {
+            // Group paths that share the same root for better organization
+            const pathsToInclude = plan
+                .filter((planItem) => {
+                const planParsed = parseEnumSplit(planItem);
+                return (planParsed.path === parsed.path ||
+                    planParsed.path.startsWith(`${parsed.path}.`));
+            })
+                .map((planItem) => parseEnumSplit(planItem).path)
+                .filter((path) => !processedPaths.has(path));
+            if (pathsToInclude.length > 0) {
+                try {
+                    const extractedSchema = extractSchemaForPaths(schema, pathsToInclude);
+                    result.push({
+                        name: parsed.path.replace(/\./g, '-'),
+                        schema: extractedSchema,
+                        targetPaths: pathsToInclude,
+                    });
+                    // Mark all included paths as processed
+                    pathsToInclude.forEach((path) => processedPaths.add(path));
+                }
+                catch (_error) {
+                    // If extraction fails, create a simple schema with just this path
+                    const shape = {};
+                    const parts = parsed.path.split('.');
+                    const leafKey = parts[parts.length - 1];
+                    if (parts.length === 1) {
+                        shape[leafKey] = schemaAtPath;
+                    }
+                    else {
+                        // For nested paths, create the nested structure
+                        let current = shape;
+                        for (let i = 0; i < parts.length - 1; i++) {
+                            const part = parts[i];
+                            current[part] = z.object({});
+                            current = current[part]
+                                .shape;
+                        }
+                        current[leafKey] = schemaAtPath;
+                    }
+                    result.push({
+                        name: parsed.path.replace(/\./g, '-'),
+                        schema: z.object(shape),
+                        targetPaths: [parsed.path],
+                    });
+                    processedPaths.add(parsed.path);
+                }
+            }
+        }
+    }
+    return result;
+}
+const parseArrayNotation = (splitPath) => {
+    const arrayMatch = splitPath.match(/^(.+)\[\](.*)$/);
+    if (arrayMatch) {
+        const [, basePath, subPath] = arrayMatch;
+        return {
+            path: basePath,
+            isArrayElement: true,
+            excludedSubArrays: subPath ? [subPath.slice(1)] : [] // Remove leading dot
+        };
+    }
+    return { path: splitPath, isArrayElement: false, excludedSubArrays: [] };
+};
+const createArrayElementSchema = (arraySchema, excludedPaths = []) => {
+    let elementSchema = arraySchema.element;
+    // Unwrap ZodLazy schemas
+    if (elementSchema && typeof elementSchema === 'object' && '_def' in elementSchema &&
+        elementSchema._def.type === 'lazy') {
+        const lazySchema = elementSchema;
+        elementSchema = lazySchema._def.getter();
+    }
+    // For array splits, we need either ZodObject or ZodUnion (for different track types)
+    if (!(elementSchema instanceof ZodObject) && elementSchema?.constructor.name !== 'ZodUnion') {
+        throw new Error(`Array element must be an object or union for array splitting, got ${elementSchema?.constructor.name}`);
+    }
+    // Create element schema with exclusions
+    let finalElementSchema = elementSchema;
+    if (elementSchema instanceof ZodObject) {
+        const elementWithExclusions = createSchemaWithExclusions(elementSchema, '', excludedPaths);
+        finalElementSchema = elementWithExclusions || elementSchema;
+    }
+    // For union schemas, we keep them as-is since they represent valid track types
+    // Wrap with index
+    return z.object({
+        index: z.number().min(0),
+        value: finalElementSchema
+    });
+};
+const createRecordElementSchema = (recordSchema) => {
+    // Access internal properties of ZodRecord
+    const keySchema = recordSchema._def.keyType || z.string();
+    const valueSchema = recordSchema._def.valueType;
+    // Transform z.record(K, V) to z.object({ key: K, value: V })
+    return z.object({
+        key: keySchema,
+        value: valueSchema
+    });
+};
+const createSchemaWithExclusions = (rootSchema, basePath, exclusions) => {
+    const baseSchema = getSchemaAtPath(rootSchema, basePath);
+    if (!(baseSchema instanceof ZodObject)) {
+        return baseSchema || null;
+    }
+    // Filter exclusions to only those that are direct children of basePath
+    const relevantExclusions = exclusions
+        .filter(exc => {
+        if (!basePath) {
+            // For root level, exclude direct children
+            return !exc.includes('.');
+        }
+        else {
+            // For nested paths, exclude direct children of this path
+            return exc.startsWith(`${basePath}.`) &&
+                !exc.slice(basePath.length + 1).includes('.');
+        }
+    })
+        .map(exc => basePath ? exc.slice(basePath.length + 1) : exc);
+    if (relevantExclusions.length === 0) {
+        return baseSchema;
+    }
+    // Create new shape excluding the specified properties
+    const newShape = {};
+    Object.entries(baseSchema.shape).forEach(([key, schema]) => {
+        if (!relevantExclusions.includes(key)) {
+            newShape[key] = schema;
+        }
+    });
+    // Return null if all properties were excluded
+    if (Object.keys(newShape).length === 0) {
+        return null;
+    }
+    return z.object(newShape);
+};

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { applyPartialUpdate } from './apply.js';
+export { decomposeSchema } from './decompose.js';
+export { PlanBuilder } from './plan-builder.js';
+export { defaultStrategyRegistry, SemanticSuggestionStrategy, SizeBasedSuggestionStrategy, SuggestionStrategyRegistry, suggestDecompositionPlan, suggestWithStrategy, } from './split-suggestions.js';
+export type { DecomposedSchema, DecompositionOptions, SizeBasedOptions, Split, SplitPlan, SuggestionStrategy, } from './types.js';
+export { conditionalEnumSplit } from './utils.js';
+export { validatePlan } from './validate.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EACL,uBAAuB,EACvB,0BAA0B,EAC1B,2BAA2B,EAC3B,0BAA0B,EAC1B,wBAAwB,EACxB,mBAAmB,GACpB,MAAM,wBAAwB,CAAC;AAEhC,YAAY,EACV,gBAAgB,EAChB,oBAAoB,EACpB,gBAAgB,EAChB,KAAK,EACL,SAAS,EACT,kBAAkB,GACnB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC"}

package/dist/index.js

@@ -0,0 +1,6 @@
+export { applyPartialUpdate } from './apply.js';
+export { decomposeSchema } from './decompose.js';
+export { PlanBuilder } from './plan-builder.js';
+export { defaultStrategyRegistry, SemanticSuggestionStrategy, SizeBasedSuggestionStrategy, SuggestionStrategyRegistry, suggestDecompositionPlan, suggestWithStrategy, } from './split-suggestions.js';
+export { conditionalEnumSplit } from './utils.js';
+export { validatePlan } from './validate.js';