@toolproof-core/genesis 1.0.47

package/dist/src/utils/constantsAndMappings.d.ts

@@ -0,0 +1,20 @@
+type JSONValue = null | boolean | number | string | JSONValue[] | {
+    [k: string]: JSONValue;
+};
+export type GeneratedConstants = {
+    Names: Record<string, string>;
+    Enums: Record<string, Record<string, string>>;
+};
+export type GeneratedMappings = {
+    HandleNameToPrefix: Record<string, string>;
+};
+export declare function extractHandlePrefixes(schema: unknown): Record<string, string>;
+export declare function extractSubschemaNames(schema: unknown): Record<string, string>;
+export declare function extractEnums(schema: unknown): Record<string, Record<string, string>>;
+export declare function extractGeneratedConstantsAndMappings(schema: JSONValue): {
+    CONSTANTS: GeneratedConstants;
+    MAPPINGS: GeneratedMappings;
+};
+export declare function renderConstantsTs(constants: GeneratedConstants): string;
+export declare function renderMappingsTs(mappings: GeneratedMappings): string;
+export {};

package/dist/src/utils/constantsAndMappings.js

@@ -0,0 +1,155 @@
+function deriveIdPrefixFromPattern(pattern) {
+    const match = /^\^([^$]+)\.\+\$$/.exec(pattern);
+    if (!match)
+        return undefined;
+    const prefix = match[1];
+    if (!prefix || /[`\n\r]/.test(prefix))
+        return undefined;
+    return prefix;
+}
+export function extractHandlePrefixes(schema) {
+    if (!schema || typeof schema !== 'object')
+        return {};
+    const defs = schema.$defs;
+    if (!defs || typeof defs !== 'object')
+        return {};
+    const defEntries = Object.entries(defs);
+    defEntries.sort(([a], [b]) => a.localeCompare(b));
+    const out = {};
+    for (const [defName, defVal] of defEntries) {
+        if (!/(Id|Handle)$/.test(defName))
+            continue;
+        if (!defVal || typeof defVal !== 'object' || Array.isArray(defVal))
+            continue;
+        const value = defVal;
+        if (value.type !== 'string')
+            continue;
+        if (typeof value.pattern !== 'string')
+            continue;
+        const prefix = deriveIdPrefixFromPattern(value.pattern);
+        if (!prefix)
+            continue;
+        out[defName] = prefix;
+    }
+    return out;
+}
+export function extractSubschemaNames(schema) {
+    if (!schema || typeof schema !== 'object')
+        return {};
+    const defs = schema.$defs;
+    if (!defs || typeof defs !== 'object')
+        return {};
+    const defEntries = Object.entries(defs);
+    defEntries.sort(([a], [b]) => a.localeCompare(b));
+    const out = {};
+    for (const [defName] of defEntries) {
+        if (!defName || /[\n\r`]/.test(defName))
+            continue;
+        out[defName] = defName;
+    }
+    return out;
+}
+export function extractEnums(schema) {
+    if (!schema || typeof schema !== 'object')
+        return {};
+    const defs = schema.$defs;
+    if (!defs || typeof defs !== 'object')
+        return {};
+    const defEntries = Object.entries(defs);
+    defEntries.sort(([a], [b]) => a.localeCompare(b));
+    const out = {};
+    for (const [defName, defVal] of defEntries) {
+        if (!/(Kind|Status)$/.test(defName))
+            continue;
+        if (!defVal || typeof defVal !== 'object' || Array.isArray(defVal))
+            continue;
+        const value = defVal;
+        if (value.type !== 'string')
+            continue;
+        if (!Array.isArray(value.enum) || value.enum.length === 0)
+            continue;
+        if (value.enum.some((item) => typeof item !== 'string'))
+            continue;
+        const members = {};
+        for (const member of value.enum) {
+            members[member] = member;
+        }
+        out[defName] = members;
+    }
+    return out;
+}
+export function extractGeneratedConstantsAndMappings(schema) {
+    const names = extractSubschemaNames(schema);
+    const enums = extractEnums(schema);
+    const handlePrefixes = extractHandlePrefixes(schema);
+    return {
+        CONSTANTS: {
+            Names: names,
+            Enums: enums,
+        },
+        MAPPINGS: {
+            HandleNameToPrefix: handlePrefixes,
+        },
+    };
+}
+function escapeTsString(value) {
+    return value
+        .replace(/\\/g, '\\\\')
+        .replace(/\r/g, '\\r')
+        .replace(/\n/g, '\\n')
+        .replace(/\t/g, '\\t')
+        .replace(/'/g, "\\'");
+}
+function renderTsStringLiteral(value) {
+    return `'${escapeTsString(value)}'`;
+}
+function isValidTsIdentifier(key) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key);
+}
+function renderTsKey(key) {
+    return isValidTsIdentifier(key) ? key : renderTsStringLiteral(key);
+}
+export function renderConstantsTs(constants) {
+    const nameKeys = Object.keys(constants.Names).sort((a, b) => a.localeCompare(b));
+    const enumKeys = Object.keys(constants.Enums).sort((a, b) => a.localeCompare(b));
+    const lines = [];
+    lines.push('const CONSTANTS = {');
+    lines.push('    Names: {');
+    for (const key of nameKeys) {
+        const value = constants.Names[key] ?? '';
+        lines.push(`        ${renderTsKey(key)}: ${renderTsStringLiteral(value)},`);
+    }
+    lines.push('    },');
+    lines.push('    Enums: {');
+    for (const key of enumKeys) {
+        const members = constants.Enums[key] ?? {};
+        lines.push(`        ${renderTsKey(key)}: {`);
+        for (const memberKey of Object.keys(members)) {
+            const value = members[memberKey] ?? '';
+            lines.push(`            ${renderTsKey(memberKey)}: ${renderTsStringLiteral(value)},`);
+        }
+        lines.push('        },');
+    }
+    lines.push('    }');
+    lines.push('} as const;');
+    lines.push('');
+    lines.push('export default CONSTANTS;');
+    lines.push('');
+    return lines.join('\n');
+}
+export function renderMappingsTs(mappings) {
+    const handleKeys = Object.keys(mappings.HandleNameToPrefix).sort((a, b) => a.localeCompare(b));
+    const lines = [];
+    lines.push('const MAPPINGS = {');
+    lines.push('    HandleNameToPrefix: {');
+    for (const key of handleKeys) {
+        const value = mappings.HandleNameToPrefix[key] ?? '';
+        lines.push(`        ${renderTsKey(key)}: ${renderTsStringLiteral(value)},`);
+    }
+    lines.push('    },');
+    lines.push('} as const;');
+    lines.push('');
+    lines.push('export default MAPPINGS;');
+    lines.push('');
+    return lines.join('\n');
+}

package/dist/src/utils/coreProjection.d.ts

@@ -0,0 +1,16 @@
+export type CoreProjectionNode = CoreProjectionDirectoryNode | CoreProjectionFileNode;
+export interface CoreProjectionBaseNode {
+    kind: 'directory' | 'file';
+    name: string;
+    path: string;
+}
+export interface CoreProjectionDirectoryNode extends CoreProjectionBaseNode {
+    kind: 'directory';
+    children: CoreProjectionNode[];
+}
+export interface CoreProjectionFileNode extends CoreProjectionBaseNode {
+    kind: 'file';
+}
+export declare function toPosixPath(value: string): string;
+export declare function shouldExclude(relativePath: string, isDirectory: boolean, excludedRelativePathPrefixes: string[]): boolean;
+export declare function compareNodes(a: CoreProjectionNode, b: CoreProjectionNode): number;

package/dist/src/utils/coreProjection.js

@@ -0,0 +1,29 @@
+import * as path from 'node:path';
+const EXCLUDED_DIRECTORY_NAMES = new Set([
+    '.git',
+    '.next',
+    'dist',
+    'node_modules',
+]);
+export function toPosixPath(value) {
+    return value.split(path.sep).join('/');
+}
+export function shouldExclude(relativePath, isDirectory, excludedRelativePathPrefixes) {
+    if (!relativePath || relativePath === '.') {
+        return false;
+    }
+    const normalizedPath = toPosixPath(relativePath);
+    const baseName = path.posix.basename(normalizedPath);
+    if (isDirectory && EXCLUDED_DIRECTORY_NAMES.has(baseName)) {
+        return true;
+    }
+    return excludedRelativePathPrefixes.some((prefix) => {
+        return normalizedPath === prefix || normalizedPath.startsWith(`${prefix}/`);
+    });
+}
+export function compareNodes(a, b) {
+    if (a.kind !== b.kind) {
+        return a.kind === 'directory' ? -1 : 1;
+    }
+    return a.name.localeCompare(b.name);
+}

package/dist/src/utils/resourceTypes.d.ts

@@ -0,0 +1,12 @@
+type JsonObject = Record<string, unknown>;
+type SchemasDocument = {
+    $defs?: Record<string, JsonObject>;
+};
+type ResourceTypeShell = JsonObject & {
+    handle?: unknown;
+    name?: unknown;
+    description?: unknown;
+};
+type ResourceTypeShellByName = Record<string, ResourceTypeShell>;
+export declare function generateResourceTypes(schemasDocument: SchemasDocument, resourceTypeShells: ResourceTypeShellByName): ResourceTypeShellByName;
+export {};

package/dist/src/utils/resourceTypes.js

@@ -0,0 +1,17 @@
+export function generateResourceTypes(schemasDocument, resourceTypeShells) {
+    if (!schemasDocument.$defs || typeof schemasDocument.$defs !== 'object') {
+        throw new Error('Schema document must have root $defs');
+    }
+    const resourceTypes = {};
+    for (const [resourceTypeName, resourceTypeShell] of Object.entries(resourceTypeShells)) {
+        const valueSchema = schemasDocument.$defs[resourceTypeName];
+        if (!valueSchema || typeof valueSchema !== 'object' || Array.isArray(valueSchema)) {
+            throw new Error(`Missing matching schema for resource type record ${resourceTypeName}`);
+        }
+        resourceTypes[resourceTypeName] = {
+            ...resourceTypeShell,
+            valueSchema,
+        };
+    }
+    return resourceTypes;
+}

package/dist/src/utils/resources.d.ts

@@ -0,0 +1,5 @@
+type JsonObject = Record<string, unknown>;
+type ResourceTypeByName = Record<string, JsonObject>;
+type ResourceByName = Record<string, JsonObject>;
+export declare function generateResources(resourceTypes: ResourceTypeByName): ResourceByName;
+export {};

package/dist/src/utils/resources.js

@@ -0,0 +1,17 @@
+const GENESIS_TIMESTAMP = '2025-11-30T00:00:00.000Z';
+export function generateResources(resourceTypes) {
+    const resources = {};
+    for (const [name, resourceType] of Object.entries(resourceTypes)) {
+        resources[name] = {
+            id: `RESOURCE-${name}`,
+            resourceTypeHandle: 'TYPE-ResourceType',
+            provenance: {
+                resourceProvenanceKind: 'genesis',
+            },
+            version: 1,
+            timestamp: GENESIS_TIMESTAMP,
+            value: resourceType,
+        };
+    }
+    return resources;
+}

package/dist/src/utils/schemaDependencies.d.ts

@@ -0,0 +1,13 @@
+type JSONValue = null | boolean | number | string | JSONValue[] | {
+    [k: string]: JSONValue;
+};
+export type DependencyMap = Record<string, string[]>;
+export declare function decodeJsonPointerSegment(segment: string): string;
+export declare function collectRefs(node: unknown, out: Set<string>): void;
+export declare function resolveInternalRefToDefKey(ref: string, defKeys: Set<string>, anchorToDef: Record<string, string>): string | null;
+export declare function generateDependencyMap(doc: {
+    $defs?: Record<string, JSONValue>;
+} | null | undefined): DependencyMap;
+export declare function normalizeDependencyMap(value: unknown): DependencyMap;
+export declare function computeTerminalsInKeyOrder(dependencyMap: DependencyMap): string[];
+export {};

package/dist/src/utils/schemaDependencies.js

@@ -0,0 +1,94 @@
+export function decodeJsonPointerSegment(segment) {
+    return segment.replace(/~1/g, '/').replace(/~0/g, '~');
+}
+export function collectRefs(node, out) {
+    if (Array.isArray(node)) {
+        for (const item of node)
+            collectRefs(item, out);
+        return;
+    }
+    if (!node || typeof node !== 'object')
+        return;
+    const obj = node;
+    const ref = obj.$ref;
+    if (typeof ref === 'string')
+        out.add(ref);
+    for (const value of Object.values(obj)) {
+        collectRefs(value, out);
+    }
+}
+export function resolveInternalRefToDefKey(ref, defKeys, anchorToDef) {
+    if (!ref.startsWith('#'))
+        return null;
+    const defsPrefix = '#/$defs/';
+    if (ref.startsWith(defsPrefix)) {
+        const rest = ref.slice(defsPrefix.length);
+        const firstSegment = rest.split('/')[0] ?? '';
+        const defKey = decodeJsonPointerSegment(firstSegment);
+        return defKeys.has(defKey) ? defKey : null;
+    }
+    if (!ref.startsWith('#/')) {
+        const anchor = ref.slice(1);
+        const mapped = anchorToDef[anchor];
+        if (mapped && defKeys.has(mapped))
+            return mapped;
+        if (defKeys.has(anchor))
+            return anchor;
+    }
+    return null;
+}
+export function generateDependencyMap(doc) {
+    const defs = doc?.$defs && typeof doc.$defs === 'object' ? doc.$defs : {};
+    const defKeys = new Set(Object.keys(defs));
+    const anchorToDef = {};
+    for (const [defKey, defSchema] of Object.entries(defs)) {
+        if (!defSchema || typeof defSchema !== 'object' || Array.isArray(defSchema))
+            continue;
+        const anchor = defSchema.$anchor;
+        if (typeof anchor === 'string' && !(anchor in anchorToDef)) {
+            anchorToDef[anchor] = defKey;
+        }
+    }
+    const dependencyMap = {};
+    for (const [defKey, defSchema] of Object.entries(defs)) {
+        const refs = new Set();
+        collectRefs(defSchema, refs);
+        const deps = new Set();
+        for (const ref of refs) {
+            const depKey = resolveInternalRefToDefKey(ref, defKeys, anchorToDef);
+            if (!depKey || depKey === defKey)
+                continue;
+            deps.add(depKey);
+        }
+        dependencyMap[defKey] = Array.from(deps);
+    }
+    return dependencyMap;
+}
+export function normalizeDependencyMap(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('Invalid dependencyMap.json: expected an object');
+    }
+    const input = value;
+    const out = {};
+    for (const [key, rawDeps] of Object.entries(input)) {
+        if (rawDeps == null) {
+            out[key] = [];
+            continue;
+        }
+        if (!Array.isArray(rawDeps)) {
+            throw new Error(`Invalid dependencyMap.json: value for ${key} must be an array`);
+        }
+        out[key] = rawDeps.filter((dep) => typeof dep === 'string');
+    }
+    return out;
+}
+export function computeTerminalsInKeyOrder(dependencyMap) {
+    const keys = Object.keys(dependencyMap);
+    const dependedUpon = new Set();
+    for (const key of keys) {
+        for (const dep of dependencyMap[key] ?? []) {
+            dependedUpon.add(dep);
+        }
+    }
+    return keys.filter((key) => !dependedUpon.has(key));
+}

package/dist/src/utils/schemaObjectNormalization.d.ts

@@ -0,0 +1 @@
+export declare function normalizeAllOfSiblingObjectKeywords(node: any): any;

package/dist/src/utils/schemaObjectNormalization.js

@@ -0,0 +1,66 @@
+export function normalizeAllOfSiblingObjectKeywords(node) {
+    if (Array.isArray(node)) {
+        let changed = false;
+        const out = node.map((item) => {
+            const next = normalizeAllOfSiblingObjectKeywords(item);
+            if (next !== item)
+                changed = true;
+            return next;
+        });
+        return changed ? out : node;
+    }
+    if (!node || typeof node !== 'object')
+        return node;
+    const hasAllOf = Array.isArray(node.allOf) && node.allOf.length > 0;
+    const looksLikeObjectSchema = node.type === 'object' ||
+        node.properties !== undefined ||
+        node.required !== undefined ||
+        node.unevaluatedProperties !== undefined ||
+        node.additionalProperties !== undefined ||
+        node.propertyNames !== undefined;
+    const siblingKeys = [
+        'type',
+        'properties',
+        'required',
+        'additionalProperties',
+        'unevaluatedProperties',
+        'propertyNames',
+        'patternProperties',
+        'dependentRequired',
+        'dependentSchemas',
+        'minProperties',
+        'maxProperties',
+    ];
+    let localNode = node;
+    if (hasAllOf && looksLikeObjectSchema) {
+        const hasSiblingObjectKeywords = siblingKeys.some((key) => key in localNode);
+        if (hasSiblingObjectKeywords) {
+            const overlay = {};
+            const nextNode = { ...localNode };
+            for (const key of siblingKeys) {
+                if (key in nextNode) {
+                    overlay[key] = nextNode[key];
+                    delete nextNode[key];
+                }
+            }
+            nextNode.allOf = [overlay, ...nextNode.allOf];
+            localNode = nextNode;
+        }
+    }
+    let changed = localNode !== node;
+    const out = localNode === node ? {} : { ...localNode };
+    for (const [key, value] of Object.entries(localNode)) {
+        const next = normalizeAllOfSiblingObjectKeywords(value);
+        if (next !== value) {
+            if (!changed) {
+                changed = true;
+                Object.assign(out, localNode);
+            }
+            out[key] = next;
+        }
+        else if (changed) {
+            out[key] = value;
+        }
+    }
+    return changed ? out : node;
+}

package/dist/src/utils/schemaRefNormalization.d.ts

@@ -0,0 +1,2 @@
+export declare function stripAnchors<T>(schema: T): T;
+export declare function normalizeAnchorsToPointers<T>(input: T): T;

package/dist/src/utils/schemaRefNormalization.js

@@ -0,0 +1,76 @@
+export function stripAnchors(schema) {
+    const seen = new WeakMap();
+    function walk(node) {
+        if (!node || typeof node !== 'object')
+            return node;
+        const existing = seen.get(node);
+        if (existing)
+            return existing;
+        if (Array.isArray(node)) {
+            const out = [];
+            seen.set(node, out);
+            for (const item of node)
+                out.push(walk(item));
+            return out;
+        }
+        const out = {};
+        seen.set(node, out);
+        for (const [key, value] of Object.entries(node)) {
+            if (key === '$anchor')
+                continue;
+            out[key] = walk(value);
+        }
+        return out;
+    }
+    return walk(schema);
+}
+export function normalizeAnchorsToPointers(input) {
+    if (!input || typeof input !== 'object')
+        return input;
+    const root = JSON.parse(JSON.stringify(input));
+    const defs = root.$defs && typeof root.$defs === 'object' ? root.$defs : {};
+    const anchorToDef = {};
+    for (const [defName, defValue] of Object.entries(defs)) {
+        if (!anchorToDef[defName]) {
+            anchorToDef[defName] = defName;
+        }
+        if (!defValue || typeof defValue !== 'object')
+            continue;
+        const envelope = defValue;
+        const valueSchema = envelope.valueSchema;
+        if (valueSchema && typeof valueSchema === 'object') {
+            const anchor = valueSchema.$anchor;
+            if (typeof anchor === 'string' && !anchorToDef[anchor]) {
+                anchorToDef[anchor] = defName;
+            }
+        }
+        else {
+            const anchor = envelope.$anchor;
+            if (typeof anchor === 'string' && !anchorToDef[anchor]) {
+                anchorToDef[anchor] = defName;
+            }
+        }
+    }
+    function walk(node) {
+        if (Array.isArray(node)) {
+            for (const item of node)
+                walk(item);
+            return;
+        }
+        if (!node || typeof node !== 'object')
+            return;
+        const obj = node;
+        if (typeof obj.$ref === 'string' && obj.$ref.startsWith('#') && !obj.$ref.startsWith('#/')) {
+            const anchor = obj.$ref.slice(1);
+            const defName = anchorToDef[anchor];
+            if (defName) {
+                obj.$ref = `#/$defs/${defName}`;
+            }
+        }
+        for (const value of Object.values(obj)) {
+            walk(value);
+        }
+    }
+    walk(root);
+    return root;
+}

package/dist/src/utils/schemaShims.d.ts

@@ -0,0 +1,2 @@
+export declare function generateShimContent(jsonFile: string, variableName: string): string;
+export declare function getShimsForFiles(jsonFiles: string[], variableName: string): Record<string, string>;

package/dist/src/utils/schemaShims.js

@@ -0,0 +1,13 @@
+import * as path from 'node:path';
+export function generateShimContent(jsonFile, variableName) {
+    return `import ${variableName} from './${jsonFile}' with { type: 'json' };\nexport default ${variableName};\n`;
+}
+export function getShimsForFiles(jsonFiles, variableName) {
+    const shims = {};
+    for (const jsonFile of jsonFiles) {
+        const baseName = path.basename(jsonFile, '.json');
+        const tsFile = `${baseName}.ts`;
+        shims[tsFile] = generateShimContent(jsonFile, variableName);
+    }
+    return shims;
+}

package/dist/src/utils/standaloneSchemas.d.ts

@@ -0,0 +1,16 @@
+export declare function isObject(value: unknown): value is Record<string, unknown>;
+export declare function deepClone<T>(value: T): T;
+export declare function extractPointerDefName(ref: string): string | null;
+export declare function collectLocalDefClosure(node: unknown, rootDefs: Record<string, unknown>): Set<string>;
+export declare function extractStandaloneSchema(schemasDocument: {
+    $defs?: Record<string, unknown>;
+}, name: string): {
+    schema: unknown;
+    warnings: string[];
+};
+export declare function generateStandaloneSchemas(schemasDocument: {
+    $defs?: Record<string, unknown>;
+}, names: string[]): {
+    standaloneSchemas: Record<string, unknown>;
+    warnings: string[];
+};

package/dist/src/utils/standaloneSchemas.js

@@ -0,0 +1,101 @@
+export function isObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+export function deepClone(value) {
+    if (Array.isArray(value))
+        return value.map((item) => deepClone(item));
+    if (isObject(value)) {
+        const out = {};
+        for (const key of Object.keys(value))
+            out[key] = deepClone(value[key]);
+        return out;
+    }
+    return value;
+}
+export function extractPointerDefName(ref) {
+    if (!ref || !ref.startsWith('#/'))
+        return null;
+    const parts = ref.slice(2).split('/');
+    if (parts.length !== 2)
+        return null;
+    if (parts[0] !== '$defs')
+        return null;
+    const defName = parts[1];
+    if (defName === undefined)
+        return null;
+    return defName.replace(/~1/g, '/').replace(/~0/g, '~');
+}
+export function collectLocalDefClosure(node, rootDefs) {
+    const needed = new Set();
+    const queue = [];
+    function visit(value) {
+        if (Array.isArray(value)) {
+            for (const item of value)
+                visit(item);
+            return;
+        }
+        if (!isObject(value))
+            return;
+        if (typeof value.$ref === 'string') {
+            const name = extractPointerDefName(value.$ref);
+            if (name && !needed.has(name)) {
+                needed.add(name);
+                queue.push(name);
+            }
+        }
+        for (const nested of Object.values(value))
+            visit(nested);
+    }
+    visit(node);
+    while (queue.length > 0) {
+        const name = queue.shift();
+        if (!name)
+            continue;
+        const def = rootDefs[name];
+        if (def === undefined)
+            continue;
+        visit(def);
+    }
+    return needed;
+}
+export function extractStandaloneSchema(schemasDocument, name) {
+    const rootDefs = schemasDocument.$defs;
+    if (!rootDefs || typeof rootDefs !== 'object') {
+        throw new Error('No $defs object found in schema document');
+    }
+    const target = rootDefs[name];
+    if (target === undefined) {
+        throw new Error(`Subschema named '${name}' not found under $defs in schema document`);
+    }
+    const needed = collectLocalDefClosure(target, rootDefs);
+    const targetClone = deepClone(target);
+    const defsOut = {};
+    const warnings = [];
+    for (const defName of needed) {
+        if (defName === name)
+            continue;
+        const defSchema = rootDefs[defName];
+        if (defSchema === undefined) {
+            warnings.push(`Warning: referenced def '${defName}' missing in root $defs (skipped).`);
+            continue;
+        }
+        defsOut[defName] = deepClone(defSchema);
+    }
+    const existingInner = isObject(targetClone) && isObject(targetClone.$defs)
+        ? targetClone.$defs
+        : {};
+    if (isObject(targetClone)) {
+        targetClone.$defs = { ...existingInner, ...defsOut };
+    }
+    return { schema: targetClone, warnings };
+}
+export function generateStandaloneSchemas(schemasDocument, names) {
+    const standaloneSchemas = {};
+    const warnings = [];
+    for (const name of names) {
+        const result = extractStandaloneSchema(schemasDocument, name);
+        standaloneSchemas[name] = result.schema;
+        warnings.push(...result.warnings);
+    }
+    return { standaloneSchemas, warnings };
+}