@kamilio/wire 0.1.9 → 0.1.11

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/json-schema/evaluate.js

@@ -0,0 +1,445 @@
+import { deepEqual, invalidResult, isMultipleOf, isObject, issue, mergeResults, typeMatches, unicodeLength, validResult } from "./utils.js";
+export function evaluateSchema(graph, value) {
+    return evaluateNode(graph, graph.root, value, {
+        instancePath: [],
+        dynamicScope: [],
+        activePairs: new Map()
+    });
+}
+function evaluateNode(graph, node, value, context) {
+    if (node.schema === true) {
+        return validResult();
+    }
+    if (node.schema === false) {
+        return invalidResult(issue(context.instancePath, "valid schema", value, "must NOT be valid"));
+    }
+    const activeValues = context.activePairs.get(node);
+    if (activeValues?.has(value) === true) {
+        return validResult();
+    }
+    const nextActivePairs = new Map(context.activePairs);
+    const nextActiveValues = new Set(activeValues ?? []);
+    nextActiveValues.add(value);
+    nextActivePairs.set(node, nextActiveValues);
+    const lastScope = context.dynamicScope.at(-1);
+    const dynamicScope = lastScope?.resourceUri === node.resourceRoot.resourceUri
+        ? context.dynamicScope
+        : [...context.dynamicScope, node.resourceRoot];
+    const nextContext = { ...context, dynamicScope, activePairs: nextActivePairs };
+    const schema = node.schema;
+    const referenceResult = evaluateReferences(graph, node, schema, value, nextContext);
+    if (node.dialect === "draft7" && typeof schema.$ref === "string") {
+        return referenceResult ?? validResult();
+    }
+    const results = [];
+    if (referenceResult !== undefined) {
+        results.push(referenceResult);
+    }
+    results.push(...evaluateApplicators(graph, node, schema, value, nextContext));
+    if (node.validationVocabulary) {
+        results.push(...evaluateValidationKeywords(node, schema, value, nextContext.instancePath));
+    }
+    if (typeof value === "string" && typeof schema.format === "string") {
+        const validator = graph.formats.get(schema.format);
+        if (validator !== undefined && validator(value) !== true) {
+            results.push(invalidResult(issue(nextContext.instancePath, `format ${schema.format}`, value, `must match format ${schema.format}`)));
+        }
+    }
+    const merged = mergeResults(results);
+    if (isObject(value)) {
+        evaluateUnevaluatedProperties(graph, node, schema, value, nextContext, merged);
+    }
+    if (Array.isArray(value)) {
+        evaluateUnevaluatedItems(graph, node, schema, value, nextContext, merged);
+    }
+    return merged;
+}
+function evaluateReferences(graph, node, schema, value, context) {
+    const results = [];
+    if (typeof schema.$ref === "string") {
+        results.push(evaluateNode(graph, graph.resolve(node, schema.$ref), value, context));
+    }
+    if (typeof schema.$dynamicRef === "string") {
+        const staticTarget = graph.resolve(node, schema.$dynamicRef);
+        const fragment = new URL(schema.$dynamicRef, node.baseUri).hash.slice(1);
+        let target = staticTarget;
+        if (fragment !== "" &&
+            !fragment.startsWith("/") &&
+            isObject(staticTarget.schema) &&
+            staticTarget.schema.$dynamicAnchor === fragment) {
+            for (const scope of context.dynamicScope) {
+                const candidate = graph.dynamicAnchor(scope, fragment);
+                if (candidate !== undefined) {
+                    target = candidate;
+                    break;
+                }
+            }
+        }
+        results.push(evaluateNode(graph, target, value, context));
+    }
+    if (typeof schema.$recursiveRef === "string") {
+        let target = graph.resolve(node, schema.$recursiveRef);
+        if (schema.$recursiveRef === "#") {
+            for (const scope of context.dynamicScope) {
+                if (isObject(scope.schema) && scope.schema.$recursiveAnchor === true) {
+                    target = scope;
+                    break;
+                }
+            }
+        }
+        results.push(evaluateNode(graph, target, value, context));
+    }
+    return results.length === 0 ? undefined : mergeResults(results);
+}
+function evaluateApplicators(graph, node, schema, value, context) {
+    const results = [];
+    for (const keyword of ["allOf", "anyOf", "oneOf"]) {
+        const schemas = schema[keyword];
+        if (!Array.isArray(schemas)) {
+            continue;
+        }
+        const branchResults = schemas.map((_, index) => evaluateChild(graph, node, `${keyword}/${index}`, value, context));
+        if (keyword === "allOf") {
+            results.push(mergeResults(branchResults));
+        }
+        else {
+            const successful = branchResults.filter((result) => result.valid);
+            const valid = keyword === "anyOf" ? successful.length > 0 : successful.length === 1;
+            if (valid) {
+                results.push(mergeResults(successful));
+            }
+            else {
+                results.push(invalidResult(issue(context.instancePath, keyword, value, keyword === "anyOf"
+                    ? "must match a schema in anyOf"
+                    : "must match exactly one schema in oneOf")));
+            }
+        }
+    }
+    if (schema.not !== undefined) {
+        const result = evaluateChild(graph, node, "not", value, context);
+        if (result.valid) {
+            results.push(invalidResult(issue(context.instancePath, "not", value, "must NOT be valid")));
+        }
+    }
+    if (schema.if !== undefined) {
+        const condition = evaluateChild(graph, node, "if", value, context);
+        const selected = condition.valid ? "then" : "else";
+        if (condition.valid) {
+            results.push(condition);
+        }
+        if (schema[selected] !== undefined) {
+            results.push(evaluateChild(graph, node, selected, value, context));
+        }
+    }
+    if (isObject(value)) {
+        results.push(...evaluateObjectApplicators(graph, node, schema, value, context));
+    }
+    if (Array.isArray(value)) {
+        results.push(...evaluateArrayApplicators(graph, node, schema, value, context));
+    }
+    return results;
+}
+function evaluateObjectApplicators(graph, node, schema, value, context) {
+    const results = [];
+    const evaluated = new Set();
+    const properties = isObject(schema.properties) ? schema.properties : {};
+    for (const key of Object.keys(properties)) {
+        if (Object.prototype.hasOwnProperty.call(value, key)) {
+            const result = evaluateChild(graph, node, `properties/${key}`, value[key], childContext(context, key));
+            evaluated.add(key);
+            results.push(markProperty(atChildLocation(result), key));
+        }
+    }
+    const patternProperties = isObject(schema.patternProperties) ? schema.patternProperties : {};
+    for (const [pattern] of Object.entries(patternProperties)) {
+        const expression = new RegExp(pattern, "u");
+        for (const [key, propertyValue] of Object.entries(value)) {
+            if (expression.test(key)) {
+                const result = evaluateChild(graph, node, `patternProperties/${pattern}`, propertyValue, childContext(context, key));
+                evaluated.add(key);
+                results.push(markProperty(atChildLocation(result), key));
+            }
+        }
+    }
+    if (schema.additionalProperties !== undefined) {
+        for (const [key, propertyValue] of Object.entries(value)) {
+            if (!evaluated.has(key)) {
+                const result = evaluateChild(graph, node, "additionalProperties", propertyValue, childContext(context, key));
+                results.push(markProperty(atChildLocation(result), key));
+            }
+        }
+    }
+    if (schema.propertyNames !== undefined) {
+        for (const key of Object.keys(value)) {
+            results.push(atChildLocation(evaluateChild(graph, node, "propertyNames", key, childContext(context, key))));
+        }
+    }
+    const dependentSchemas = isObject(schema.dependentSchemas) ? schema.dependentSchemas : {};
+    for (const key of Object.keys(dependentSchemas)) {
+        if (Object.prototype.hasOwnProperty.call(value, key)) {
+            results.push(evaluateChild(graph, node, `dependentSchemas/${key}`, value, context));
+        }
+    }
+    if (node.dialect === "draft7" && isObject(schema.dependencies)) {
+        for (const [key, dependency] of Object.entries(schema.dependencies)) {
+            if (Object.prototype.hasOwnProperty.call(value, key) && !Array.isArray(dependency)) {
+                results.push(evaluateInline(graph, node, dependency, value, context, `dependencies/${key}`));
+            }
+        }
+    }
+    return results;
+}
+function evaluateArrayApplicators(graph, node, schema, value, context) {
+    const results = [];
+    if (node.dialect === "draft2020-12") {
+        const prefixItems = Array.isArray(schema.prefixItems) ? schema.prefixItems : [];
+        prefixItems.forEach((_, index) => {
+            if (index < value.length) {
+                const result = evaluateChild(graph, node, `prefixItems/${index}`, value[index], childContext(context, String(index)));
+                results.push(markItem(atChildLocation(result), index));
+            }
+        });
+        if (schema.items !== undefined && !Array.isArray(schema.items)) {
+            for (let index = prefixItems.length; index < value.length; index += 1) {
+                const result = evaluateChild(graph, node, "items", value[index], childContext(context, String(index)));
+                results.push(markItem(atChildLocation(result), index));
+            }
+        }
+    }
+    else if (Array.isArray(schema.items)) {
+        schema.items.forEach((_, index) => {
+            if (index < value.length) {
+                const result = evaluateChild(graph, node, `items/${index}`, value[index], childContext(context, String(index)));
+                results.push(markItem(atChildLocation(result), index));
+            }
+        });
+        if (schema.additionalItems !== undefined) {
+            for (let index = schema.items.length; index < value.length; index += 1) {
+                const result = evaluateChild(graph, node, "additionalItems", value[index], childContext(context, String(index)));
+                results.push(markItem(atChildLocation(result), index));
+            }
+        }
+    }
+    else if (schema.items !== undefined) {
+        for (let index = 0; index < value.length; index += 1) {
+            const result = evaluateChild(graph, node, "items", value[index], childContext(context, String(index)));
+            results.push(markItem(atChildLocation(result), index));
+        }
+    }
+    if (schema.contains !== undefined) {
+        const containsResults = value.map((item, index) => evaluateChild(graph, node, "contains", item, childContext(context, String(index))));
+        const matching = containsResults
+            .map((result, index) => ({ result, index }))
+            .filter(({ result }) => result.valid);
+        const minimum = node.dialect === "draft2020-12" && typeof schema.minContains === "number"
+            ? schema.minContains
+            : 1;
+        const maximum = node.dialect === "draft2020-12" && typeof schema.maxContains === "number"
+            ? schema.maxContains
+            : Number.POSITIVE_INFINITY;
+        if (matching.length < minimum || matching.length > maximum) {
+            results.push(invalidResult(issue(context.instancePath, "contains", value, "must contain required matching items")));
+        }
+        else if (node.dialect === "draft2020-12") {
+            const result = validResult();
+            for (const match of matching) {
+                result.evaluatedItems.add(match.index);
+            }
+            results.push(result);
+        }
+    }
+    return results;
+}
+function evaluateValidationKeywords(node, schema, value, path) {
+    const results = [];
+    const types = typeof schema.type === "string" ? [schema.type] : Array.isArray(schema.type) ? schema.type : [];
+    if (types.length > 0 &&
+        !types.some((type) => typeof type === "string" && typeMatches(type, value))) {
+        results.push(invalidResult(issue(path, types.join(","), value, `must be ${types.join(",")}`)));
+        return results;
+    }
+    if (schema.const !== undefined && !deepEqual(schema.const, value)) {
+        results.push(invalidResult(issue(path, "const", value, "must be equal to constant")));
+    }
+    if (Array.isArray(schema.enum) && !schema.enum.some((entry) => deepEqual(entry, value))) {
+        results.push(invalidResult(issue(path, "enum", value, "must be equal to one of the allowed values")));
+    }
+    if (typeof value === "number" && Number.isFinite(value)) {
+        evaluateNumberKeywords(schema, value, path, results);
+    }
+    if (typeof value === "string") {
+        evaluateStringKeywords(schema, value, path, results);
+    }
+    if (Array.isArray(value)) {
+        evaluateArrayKeywords(schema, value, path, results);
+    }
+    if (isObject(value)) {
+        evaluateObjectKeywords(node, schema, value, path, results);
+    }
+    return results;
+}
+function evaluateNumberKeywords(schema, value, path, results) {
+    if (typeof schema.multipleOf === "number" && !isMultipleOf(value, schema.multipleOf)) {
+        results.push(invalidResult(issue(path, `multiple of ${schema.multipleOf}`, value, `must be multiple of ${schema.multipleOf}`)));
+    }
+    if (typeof schema.maximum === "number" && value > schema.maximum) {
+        results.push(invalidResult(issue(path, `<= ${schema.maximum}`, value, `must be <= ${schema.maximum}`)));
+    }
+    if (typeof schema.minimum === "number" && value < schema.minimum) {
+        results.push(invalidResult(issue(path, `>= ${schema.minimum}`, value, `must be >= ${schema.minimum}`)));
+    }
+    if (typeof schema.exclusiveMaximum === "number" && value >= schema.exclusiveMaximum) {
+        results.push(invalidResult(issue(path, `< ${schema.exclusiveMaximum}`, value, `must be < ${schema.exclusiveMaximum}`)));
+    }
+    if (typeof schema.exclusiveMinimum === "number" && value <= schema.exclusiveMinimum) {
+        results.push(invalidResult(issue(path, `> ${schema.exclusiveMinimum}`, value, `must be > ${schema.exclusiveMinimum}`)));
+    }
+}
+function evaluateStringKeywords(schema, value, path, results) {
+    const length = unicodeLength(value);
+    if (typeof schema.maxLength === "number" && length > schema.maxLength) {
+        results.push(invalidResult(issue(path, `length <= ${schema.maxLength}`, value, `must NOT have more than ${schema.maxLength} characters`)));
+    }
+    if (typeof schema.minLength === "number" && length < schema.minLength) {
+        results.push(invalidResult(issue(path, `length >= ${schema.minLength}`, value, `must NOT have fewer than ${schema.minLength} characters`)));
+    }
+    if (typeof schema.pattern === "string" && !new RegExp(schema.pattern, "u").test(value)) {
+        results.push(invalidResult(issue(path, `pattern ${schema.pattern}`, value, `must match pattern ${schema.pattern}`)));
+    }
+}
+function evaluateArrayKeywords(schema, value, path, results) {
+    if (typeof schema.maxItems === "number" && value.length > schema.maxItems) {
+        results.push(invalidResult(issue(path, `items <= ${schema.maxItems}`, value, `must NOT have more than ${schema.maxItems} items`)));
+    }
+    if (typeof schema.minItems === "number" && value.length < schema.minItems) {
+        results.push(invalidResult(issue(path, `items >= ${schema.minItems}`, value, `must NOT have fewer than ${schema.minItems} items`)));
+    }
+    if (schema.uniqueItems === true) {
+        for (let left = 0; left < value.length; left += 1) {
+            for (let right = left + 1; right < value.length; right += 1) {
+                if (deepEqual(value[left], value[right])) {
+                    results.push(invalidResult(issue(path, "unique items", value, "must NOT have duplicate items")));
+                    return;
+                }
+            }
+        }
+    }
+}
+function evaluateObjectKeywords(node, schema, value, path, results) {
+    const keys = Object.keys(value);
+    if (typeof schema.maxProperties === "number" && keys.length > schema.maxProperties) {
+        results.push(invalidResult(issue(path, `properties <= ${schema.maxProperties}`, value, `must NOT have more than ${schema.maxProperties} properties`)));
+    }
+    if (typeof schema.minProperties === "number" && keys.length < schema.minProperties) {
+        results.push(invalidResult(issue(path, `properties >= ${schema.minProperties}`, value, `must NOT have fewer than ${schema.minProperties} properties`)));
+    }
+    if (Array.isArray(schema.required)) {
+        for (const key of schema.required) {
+            if (typeof key === "string" && !Object.prototype.hasOwnProperty.call(value, key)) {
+                results.push(invalidResult(issue([...path, key], "required", undefined, `must have required property '${key}'`)));
+            }
+        }
+    }
+    const dependentRequired = isObject(schema.dependentRequired) ? schema.dependentRequired : {};
+    for (const [key, dependencies] of Object.entries(dependentRequired)) {
+        if (Object.prototype.hasOwnProperty.call(value, key) && Array.isArray(dependencies)) {
+            addMissingDependencies(value, dependencies, path, results);
+        }
+    }
+    if (node.dialect === "draft7" && isObject(schema.dependencies)) {
+        for (const [key, dependencies] of Object.entries(schema.dependencies)) {
+            if (Object.prototype.hasOwnProperty.call(value, key) && Array.isArray(dependencies)) {
+                addMissingDependencies(value, dependencies, path, results);
+            }
+        }
+    }
+}
+function addMissingDependencies(value, dependencies, path, results) {
+    for (const dependency of dependencies) {
+        if (typeof dependency === "string" &&
+            !Object.prototype.hasOwnProperty.call(value, dependency)) {
+            results.push(invalidResult(issue([...path, dependency], "dependency", undefined, `must have property '${dependency}'`)));
+        }
+    }
+}
+function evaluateUnevaluatedProperties(graph, node, schema, value, context, result) {
+    if (node.dialect !== "draft2020-12" || schema.unevaluatedProperties === undefined) {
+        return;
+    }
+    for (const [key, propertyValue] of Object.entries(value)) {
+        if (!result.evaluatedProperties.has(key)) {
+            const propertyResult = evaluateChild(graph, node, "unevaluatedProperties", propertyValue, childContext(context, key));
+            propertyResult.evaluatedProperties.add(key);
+            mergeInto(result, propertyResult);
+        }
+    }
+}
+function evaluateUnevaluatedItems(graph, node, schema, value, context, result) {
+    if (node.dialect !== "draft2020-12" || schema.unevaluatedItems === undefined) {
+        return;
+    }
+    for (let index = 0; index < value.length; index += 1) {
+        if (!result.evaluatedItems.has(index)) {
+            const itemResult = evaluateChild(graph, node, "unevaluatedItems", value[index], childContext(context, String(index)));
+            itemResult.evaluatedItems.add(index);
+            mergeInto(result, itemResult);
+        }
+    }
+}
+function evaluateChild(graph, node, key, value, context) {
+    const child = node.children.get(key);
+    if (child === undefined) {
+        return validResult();
+    }
+    return evaluateNode(graph, child, value, context);
+}
+function evaluateInline(graph, node, schema, value, context, key) {
+    const child = node.children.get(key);
+    if (child !== undefined) {
+        return evaluateNode(graph, child, value, context);
+    }
+    if (typeof schema !== "boolean" && !isObject(schema)) {
+        return validResult();
+    }
+    const inlineNode = {
+        schema: schema,
+        documentId: node.documentId,
+        dialect: node.dialect,
+        baseUri: node.baseUri,
+        resourceUri: node.resourceUri,
+        resourceRoot: node.resourceRoot,
+        pointer: node.pointer,
+        validationVocabulary: node.validationVocabulary,
+        children: new Map()
+    };
+    return evaluateNode(graph, inlineNode, value, context);
+}
+function childContext(context, segment) {
+    return { ...context, instancePath: [...context.instancePath, segment] };
+}
+function mergeInto(target, source) {
+    target.valid &&= source.valid;
+    target.issues.push(...source.issues);
+    for (const key of source.evaluatedProperties) {
+        target.evaluatedProperties.add(key);
+    }
+    for (const index of source.evaluatedItems) {
+        target.evaluatedItems.add(index);
+    }
+}
+function atChildLocation(result) {
+    return {
+        valid: result.valid,
+        issues: result.issues,
+        evaluatedProperties: new Set(),
+        evaluatedItems: new Set()
+    };
+}
+function markProperty(result, key) {
+    result.evaluatedProperties.add(key);
+    return result;
+}
+function markItem(result, index) {
+    result.evaluatedItems.add(index);
+    return result;
+}

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/json-schema/index.d.ts

@@ -0,0 +1,5 @@
+import type { ValidationIssue } from "../validate.js";
+import type { CompileJsonSchemaOptions, CompiledJsonSchema } from "./types.js";
+export type { CompileJsonSchemaOptions, CompiledJsonSchema } from "./types.js";
+export declare function compileJsonSchema(schema: unknown, options?: CompileJsonSchemaOptions): CompiledJsonSchema;
+export declare function formatIssues(issues: readonly ValidationIssue[]): string;

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/json-schema/index.js

@@ -0,0 +1,19 @@
+import { compileGraph } from "./compiler.js";
+import { evaluateSchema } from "./evaluate.js";
+export function compileJsonSchema(schema, options = {}) {
+    const graph = compileGraph(schema, options);
+    return {
+        validate(value) {
+            const result = evaluateSchema(graph, value);
+            return result.valid ? { ok: true, value } : { ok: false, issues: result.issues };
+        }
+    };
+}
+export function formatIssues(issues) {
+    return issues
+        .map((current) => {
+        const path = current.path.length === 0 ? "data" : `data/${current.path.join("/")}`;
+        return `${path} ${current.message}`;
+    })
+        .join(", ");
+}

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/json-schema/normalize-nullability.d.ts

@@ -0,0 +1 @@
+export declare function normalizeLegacyNullability(source: object): Record<string, unknown>;

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/json-schema/normalize-nullability.js

@@ -0,0 +1,69 @@
+import { dialectFor } from "./utils.js";
+const schemaMaps = new Set(["properties", "$defs", "definitions", "patternProperties", "dependentSchemas", "dependencies"]);
+const schemaArrays = new Set(["allOf", "anyOf", "oneOf", "prefixItems", "items"]);
+const schemaValues = new Set(["items", "additionalProperties", "additionalItems", "contains", "not", "if", "then", "else", "propertyNames", "unevaluatedProperties", "unevaluatedItems"]);
+const schemaIdentity = new Set(["$id", "id", "$schema", "$anchor", "$dynamicAnchor", "$defs", "definitions", "description", "default"]);
+export function normalizeLegacyNullability(source) {
+    const locations = new Map();
+    const resourceIds = new Map();
+    const references = [];
+    const pointer = (path) => path.length === 0 ? "" : `/${path.map((part) => part.split("~").join("~0").split("/").join("~1")).join("/")}`;
+    const walk = (node, before, after, resourceBefore, resourceAfter, base = "https://toolcraft.invalid/schema", inheritedDialect = "draft2020-12") => {
+        if (typeof node !== "object" || node === null || Array.isArray(node))
+            return structuredClone(node);
+        const object = node;
+        const dialect = dialectFor(object, inheritedDialect);
+        const identifier = dialect === "draft7" ? object.$id ?? object.id : object.$id;
+        if (typeof identifier === "string") {
+            resourceBefore = before;
+            resourceAfter = after;
+            base = new URL(identifier, base).href.split("#", 1)[0];
+        }
+        const resource = pointer(resourceBefore);
+        resourceIds.set(base, resource);
+        locations.set(`${resource}|${pointer(before.slice(resourceBefore.length))}`, pointer(after.slice(resourceAfter.length)));
+        const result = {};
+        const validation = {};
+        const nullable = object.nullable === true;
+        for (const [key, value] of Object.entries(object)) {
+            if (key === "nullable")
+                continue;
+            const target = nullable && !schemaIdentity.has(key) ? validation : result;
+            const nextAfter = [...after, ...(target === validation ? ["anyOf", "0"] : []), key];
+            let converted;
+            if (schemaMaps.has(key) && typeof value === "object" && value !== null && !Array.isArray(value)) {
+                converted = Object.fromEntries(Object.entries(value).map(([name, child]) => [name,
+                    walk(child, [...before, key, name], [...nextAfter, name], resourceBefore, resourceAfter, base, dialect)]));
+            }
+            else if (schemaArrays.has(key) && Array.isArray(value)) {
+                converted = value.map((child, index) => walk(child, [...before, key, String(index)], [...nextAfter, String(index)], resourceBefore, resourceAfter, base, dialect));
+            }
+            else if (schemaValues.has(key)) {
+                converted = walk(value, [...before, key], nextAfter, resourceBefore, resourceAfter, base, dialect);
+            }
+            else
+                converted = structuredClone(value);
+            Object.defineProperty(target, key, { value: converted, enumerable: true, configurable: true, writable: true });
+            if ((key === "$ref" || key === "$dynamicRef") && typeof value === "string")
+                references.push({ holder: target, key, value, base });
+        }
+        if (nullable)
+            result.anyOf = [validation, { type: "null" }];
+        return result;
+    };
+    const normalized = walk(source, [], [], [], []);
+    for (const reference of references) {
+        const resolved = new URL(reference.value, reference.base);
+        if (!resolved.hash.startsWith("#/"))
+            continue;
+        const resource = resourceIds.get(resolved.href.slice(0, -resolved.hash.length));
+        if (resource === undefined)
+            continue;
+        const original = decodeURIComponent(resolved.hash.slice(1));
+        const destination = locations.get(`${resource}|${original}`);
+        if (destination !== undefined && destination !== original) {
+            reference.holder[reference.key] = `${reference.value.slice(0, reference.value.indexOf("#") + 1)}${destination}`;
+        }
+    }
+    return normalized;
+}

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/json-schema/properties.d.ts

@@ -0,0 +1,16 @@
+import type { ValidationResult } from "../validate.js";
+import type { CompileJsonSchemaOptions } from "./types.js";
+export interface JsonSchemaProperty {
+    readonly name: string;
+    /** Required regardless of the object's selected alternative or condition. */
+    readonly required: boolean;
+    /** Isolated annotation/schema copies, including resolved references. */
+    readonly schemas: readonly unknown[];
+    /** Candidate hint: accepts a value matching at least one advertised declaration.
+     * Validate the complete object to enforce compositions and conditional rules. */
+    validate(value: unknown): ValidationResult<unknown>;
+}
+/** Project names and candidate validators while retaining the native reference graph.
+ * Property hints cover declarations in refs, compositions and conditional branches;
+ * full object validation remains necessary for branch-dependent constraints. */
+export declare function projectJsonSchemaProperties(schema: unknown, options?: CompileJsonSchemaOptions): readonly JsonSchemaProperty[];