toolcraft 0.0.115 → 0.0.116

package/composition.json

@@ -36,36 +36,11 @@
       "version": "0.0.1",
       "license": "MIT"
     },
-    {
-      "name": "ajv",
-      "version": "8.20.0",
-      "license": "MIT"
-    },
     {
       "name": "auth-store",
       "version": "0.0.1",
       "license": "MIT"
     },
-    {
-      "name": "fast-deep-equal",
-      "version": "3.1.3",
-      "license": "MIT"
-    },
-    {
-      "name": "fast-uri",
-      "version": "3.1.2",
-      "license": "BSD-3-Clause"
-    },
-    {
-      "name": "json-schema-traverse",
-      "version": "1.0.0",
-      "license": "MIT"
-    },
-    {
-      "name": "require-from-string",
-      "version": "2.0.2",
-      "license": "MIT"
-    },
     {
       "name": "tiny-mcp-client",
       "version": "0.1.0",
@@ -78,7 +53,7 @@
     },
     {
       "name": "toolcraft",
-      "version": "0.0.115",
+      "version": "0.0.116",
       "license": "MIT"
     },
     {
@@ -88,7 +63,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.115",
+      "version": "0.0.116",
       "license": "MIT"
     }
   ]

package/dist/composition.json

@@ -36,36 +36,11 @@
       "version": "0.0.1",
       "license": "MIT"
     },
-    {
-      "name": "ajv",
-      "version": "8.20.0",
-      "license": "MIT"
-    },
     {
       "name": "auth-store",
       "version": "0.0.1",
       "license": "MIT"
     },
-    {
-      "name": "fast-deep-equal",
-      "version": "3.1.3",
-      "license": "MIT"
-    },
-    {
-      "name": "fast-uri",
-      "version": "3.1.2",
-      "license": "BSD-3-Clause"
-    },
-    {
-      "name": "json-schema-traverse",
-      "version": "1.0.0",
-      "license": "MIT"
-    },
-    {
-      "name": "require-from-string",
-      "version": "2.0.2",
-      "license": "MIT"
-    },
     {
       "name": "tiny-mcp-client",
       "version": "0.1.0",
@@ -78,7 +53,7 @@
     },
     {
       "name": "toolcraft",
-      "version": "0.0.115",
+      "version": "0.0.116",
       "license": "MIT"
     },
     {
@@ -88,7 +63,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.115",
+      "version": "0.0.116",
       "license": "MIT"
     }
   ]

package/node_modules/tiny-stdio-mcp-server/dist/composition.json

@@ -0,0 +1,15 @@
+{
+  "schemaVersion": 1,
+  "packages": [
+    {
+      "name": "tiny-stdio-mcp-server",
+      "version": "0.1.0",
+      "license": "MIT"
+    },
+    {
+      "name": "toolcraft-schema",
+      "version": "0.0.116",
+      "license": "MIT"
+    }
+  ]
+}

package/node_modules/tiny-stdio-mcp-server/dist/server.js

@@ -1,5 +1,5 @@
 import * as readline from "readline";
-import AjvModule from "ajv";
+import { compileJsonSchema, formatIssues } from "toolcraft-schema";
 import uriTemplateParser from "uri-template";
 import UriTemplate from "uri-template-lite";
 import { JSON_RPC_ERROR_CODES, ToolError } from "./types.js";
@@ -7,13 +7,20 @@ import { parseMessage, formatSuccessResponse, formatErrorResponse } from "./json
 import { toContentBlocks } from "./content/convert.js";
 const PROTOCOL_VERSION = "2025-11-25";
 const SUPPORTED_PROTOCOL_VERSIONS = new Set(["2025-03-26", "2025-06-18", PROTOCOL_VERSION]);
+function compileToolSchema(schema) {
+    try {
+        return compileJsonSchema(schema);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`schema is invalid: ${message}`, { cause: error });
+    }
+}
 export function createServer(options) {
     if (options.toolCallTimeoutMs !== undefined &&
         (!Number.isInteger(options.toolCallTimeoutMs) || options.toolCallTimeoutMs <= 0)) {
         throw new Error("toolCallTimeoutMs must be a positive integer.");
     }
-    const Ajv = "default" in AjvModule ? AjvModule.default : AjvModule;
-    const jsonSchemaValidator = new Ajv({ strict: false });
     const supportNotifications = options.supportNotifications !== false;
     const supportResourceSubscriptions = options.supportResourceSubscriptions !== false;
     const tools = new Map();
@@ -124,13 +131,13 @@ export function createServer(options) {
                 };
             }
             const toolArgs = (params?.arguments ?? {});
-            if (options.validateToolArguments !== false && !tool.inputValidator(toolArgs)) {
-                const errors = tool.inputValidator.errors ?? [];
+            const inputValidation = tool.inputValidator.validate(toolArgs);
+            if (options.validateToolArguments !== false && !inputValidation.ok) {
                 return {
                     error: {
                         code: JSON_RPC_ERROR_CODES.INVALID_PARAMS,
-                        message: `Invalid tool arguments: ${jsonSchemaValidator.errorsText(errors)}`,
-                        data: errors
+                        message: `Invalid tool arguments: ${formatIssues(inputValidation.issues)}`,
+                        data: inputValidation.issues
                     }
                 };
             }
@@ -156,11 +163,9 @@ export function createServer(options) {
                     });
                 }
                 const result = normalizeToolResult(handlerResult, tool.outputSchema);
-                if (result.isError !== true &&
-                    tool.outputValidator !== undefined &&
-                    !tool.outputValidator(result.structuredContent)) {
-                    const errors = tool.outputValidator.errors ?? [];
-                    throw new ToolError(JSON_RPC_ERROR_CODES.INTERNAL_ERROR, `Invalid structured tool result: ${jsonSchemaValidator.errorsText(errors)}`, errors);
+                const outputValidation = tool.outputValidator?.validate(result.structuredContent);
+                if (result.isError !== true && outputValidation !== undefined && !outputValidation.ok) {
+                    throw new ToolError(JSON_RPC_ERROR_CODES.INTERNAL_ERROR, `Invalid structured tool result: ${formatIssues(outputValidation.issues)}`, outputValidation.issues);
                 }
                 return { result };
             }
@@ -391,11 +396,11 @@ export function createServer(options) {
             if (tools.has(name)) {
                 throw new Error(`Tool already registered: ${name}`);
             }
-            const inputValidator = jsonSchemaValidator.compile(inputSchema);
+            const inputValidator = compileToolSchema(inputSchema);
             let outputValidator;
             if (outputSchema !== undefined) {
                 assertObjectRootSchema(outputSchema, "outputSchema");
-                outputValidator = jsonSchemaValidator.compile(outputSchema);
+                outputValidator = compileToolSchema(outputSchema);
             }
             tools.set(name, {
                 name,
@@ -413,11 +418,11 @@ export function createServer(options) {
             if (tools.has(definition.name)) {
                 throw new Error(`Tool already registered: ${definition.name}`);
             }
-            const inputValidator = jsonSchemaValidator.compile(definition.inputSchema);
+            const inputValidator = compileToolSchema(definition.inputSchema);
             let outputValidator;
             if (definition.outputSchema !== undefined) {
                 assertObjectRootSchema(definition.outputSchema, "outputSchema");
-                outputValidator = jsonSchemaValidator.compile(definition.outputSchema);
+                outputValidator = compileToolSchema(definition.outputSchema);
             }
             tools.set(definition.name, {
                 ...definition,

package/node_modules/tiny-stdio-mcp-server/package.json

@@ -24,7 +24,9 @@
   },
   "scripts": {
     "build": "node ../../scripts/guard-package-dist.mjs && tsc",
-    "prepublishOnly": "tsc"
+    "prepublishOnly": "tsc",
+    "prepack": "node ../../scripts/manage-bundled-workspace-deps.mjs prepare . toolcraft-schema",
+    "postpack": "node ../../scripts/manage-bundled-workspace-deps.mjs cleanup . toolcraft-schema"
   },
   "files": [
     "LICENSE",

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

@@ -178,5 +178,7 @@ export declare const S: {
 export declare function toJsonSchema(schema: AnySchema): JsonSchema;
 export declare function toJsonSchemaDocument(schema: AnySchema, options?: JsonSchemaDocumentOptions): JsonSchemaDocument;
 export { Json, OneOf, RecordBuilder as Record, Union, validate };
+export { compileJsonSchema, formatIssues } from "./json-schema/index.js";
+export type { CompileJsonSchemaOptions, CompiledJsonSchema } from "./json-schema/index.js";
 export type { JsonSchemaDocument, JsonSchemaDocumentOptions } from "./json-schema-document.js";
 export type { JsonValue, JsonValueSchema, OneOfSchema, RecordSchema, UnionSchema, ValidationIssue, ValidationResult };

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

@@ -292,3 +292,4 @@ export function toJsonSchemaDocument(schema, options = {}) {
     return createJsonSchemaDocument(toJsonSchema(schema), options);
 }
 export { Json, OneOf, RecordBuilder as Record, Union, validate };
+export { compileJsonSchema, formatIssues } from "./json-schema/index.js";

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

@@ -0,0 +1,11 @@
+import type { CompileJsonSchemaOptions, SchemaNode } from "./types.js";
+export interface CompiledGraph {
+    root: SchemaNode;
+    locations: Map<string, SchemaNode>;
+    resources: Map<string, SchemaNode>;
+    anchors: Map<string, SchemaNode>;
+    dynamicAnchors: Map<string, SchemaNode>;
+    resolve(node: SchemaNode, reference: string): SchemaNode;
+    dynamicAnchor(scope: SchemaNode, name: string): SchemaNode | undefined;
+}
+export declare function compileGraph(schema: unknown, options?: CompileJsonSchemaOptions): CompiledGraph;

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

@@ -0,0 +1,390 @@
+import { dialectFor, escapePointer, fragmentOf, isObject, isSchema, resolveUri, withoutFragment } from "./utils.js";
+const schemaMapKeywords = new Set([
+    "$defs",
+    "definitions",
+    "properties",
+    "patternProperties",
+    "dependentSchemas",
+    "dependencies"
+]);
+const schemaArrayKeywords = new Set(["allOf", "anyOf", "oneOf", "prefixItems"]);
+const schemaKeywords = new Set([
+    "additionalItems",
+    "additionalProperties",
+    "contains",
+    "else",
+    "if",
+    "items",
+    "not",
+    "propertyNames",
+    "then",
+    "unevaluatedItems",
+    "unevaluatedProperties"
+]);
+const draftTypes = ["null", "boolean", "object", "array", "number", "integer", "string"];
+const draftTypeSet = new Set(draftTypes);
+const metaSchemaKeywordProperties = {
+    type: {
+        anyOf: [
+            { enum: draftTypes },
+            { type: "array", items: { enum: draftTypes }, minItems: 1, uniqueItems: true }
+        ]
+    },
+    minLength: { type: "integer", minimum: 0 },
+    maxLength: { type: "integer", minimum: 0 },
+    minItems: { type: "integer", minimum: 0 },
+    maxItems: { type: "integer", minimum: 0 },
+    minProperties: { type: "integer", minimum: 0 },
+    maxProperties: { type: "integer", minimum: 0 }
+};
+const builtInRegistry = {
+    "https://json-schema.org/draft/2020-12/schema": {
+        $id: "https://json-schema.org/draft/2020-12/schema",
+        type: ["object", "boolean"],
+        properties: {
+            ...metaSchemaKeywordProperties,
+            $defs: { type: "object", additionalProperties: { $ref: "#" } }
+        }
+    },
+    "http://json-schema.org/draft-07/schema": {
+        $id: "http://json-schema.org/draft-07/schema#",
+        type: ["object", "boolean"],
+        properties: {
+            ...metaSchemaKeywordProperties,
+            definitions: { type: "object", additionalProperties: { $ref: "#" } }
+        }
+    }
+};
+function mapKey(dialect, uri) {
+    return `${dialect}\0${uri}`;
+}
+function assertSchemaArray(value, keyword) {
+    if (!Array.isArray(value) || value.length === 0 || !value.every(isSchema)) {
+        throw new Error(`${keyword} must be a non-empty array of schemas.`);
+    }
+}
+function assertStringArray(value, keyword) {
+    if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) {
+        throw new Error(`${keyword} must be an array of strings.`);
+    }
+    if (new Set(value).size !== value.length) {
+        throw new Error(`${keyword} must contain unique strings.`);
+    }
+}
+function assertSchemaMap(value, keyword) {
+    if (!isObject(value) || !Object.values(value).every(isSchema)) {
+        throw new Error(`${keyword} must be an object containing schemas.`);
+    }
+}
+function assertNonNegativeInteger(value, keyword) {
+    if (!Number.isInteger(value) || value < 0) {
+        throw new Error(`${keyword} must be a non-negative integer.`);
+    }
+}
+function validateSchemaObject(schema, dialect) {
+    if (schema.type !== undefined) {
+        const types = Array.isArray(schema.type) ? schema.type : [schema.type];
+        if (types.length === 0 ||
+            !types.every((type) => typeof type === "string" && draftTypeSet.has(type)) ||
+            new Set(types).size !== types.length) {
+            throw new Error("type must be a JSON Schema type or a unique array of JSON Schema types.");
+        }
+    }
+    for (const keyword of ["minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum"]) {
+        if (schema[keyword] !== undefined && typeof schema[keyword] !== "number") {
+            throw new Error(`${keyword} must be a number.`);
+        }
+    }
+    if (schema.multipleOf !== undefined &&
+        (typeof schema.multipleOf !== "number" || schema.multipleOf <= 0)) {
+        throw new Error("multipleOf must be a number greater than zero.");
+    }
+    for (const keyword of [
+        "minLength",
+        "maxLength",
+        "minItems",
+        "maxItems",
+        "minContains",
+        "maxContains",
+        "minProperties",
+        "maxProperties"
+    ]) {
+        if (schema[keyword] !== undefined) {
+            assertNonNegativeInteger(schema[keyword], keyword);
+        }
+    }
+    if (schema.pattern !== undefined && typeof schema.pattern !== "string") {
+        throw new Error("pattern must be a string.");
+    }
+    for (const keyword of ["uniqueItems", "$recursiveAnchor"]) {
+        if (schema[keyword] !== undefined && typeof schema[keyword] !== "boolean") {
+            throw new Error(`${keyword} must be a boolean.`);
+        }
+    }
+    if (schema.required !== undefined) {
+        assertStringArray(schema.required, "required");
+    }
+    if (schema.dependentRequired !== undefined) {
+        if (!isObject(schema.dependentRequired)) {
+            throw new Error("dependentRequired must be an object containing string arrays.");
+        }
+        for (const dependencies of Object.values(schema.dependentRequired)) {
+            assertStringArray(dependencies, "dependentRequired");
+        }
+    }
+    for (const keyword of schemaMapKeywords) {
+        const value = schema[keyword];
+        if (value === undefined || keyword === "dependencies")
+            continue;
+        assertSchemaMap(value, keyword);
+    }
+    if (schema.dependencies !== undefined) {
+        if (!isObject(schema.dependencies)) {
+            throw new Error("dependencies must be an object containing schemas or string arrays.");
+        }
+        for (const dependency of Object.values(schema.dependencies)) {
+            if (!isSchema(dependency))
+                assertStringArray(dependency, "dependencies");
+        }
+    }
+    for (const keyword of ["allOf", "anyOf", "oneOf"]) {
+        if (schema[keyword] !== undefined)
+            assertSchemaArray(schema[keyword], keyword);
+    }
+    if (schema.prefixItems !== undefined) {
+        if (!Array.isArray(schema.prefixItems) || !schema.prefixItems.every(isSchema)) {
+            throw new Error("prefixItems must be an array of schemas.");
+        }
+    }
+    for (const keyword of schemaKeywords) {
+        const value = schema[keyword];
+        if (value === undefined)
+            continue;
+        if (keyword === "items" && dialect === "draft7" && Array.isArray(value)) {
+            if (!value.every(isSchema))
+                throw new Error("items must contain only schemas.");
+        }
+        else if (!isSchema(value)) {
+            throw new Error(`${keyword} must be a schema.`);
+        }
+    }
+    if (schema.enum !== undefined && !Array.isArray(schema.enum)) {
+        throw new Error("enum must be an array.");
+    }
+}
+export function compileGraph(schema, options = {}) {
+    if (!isSchema(schema)) {
+        throw new Error("JSON Schema must be a boolean or object.");
+    }
+    const locations = new Map();
+    const resources = new Map();
+    const anchors = new Map();
+    const dynamicAnchors = new Map();
+    const nodesBySchema = new WeakMap();
+    const pendingReferences = [];
+    const registry = { ...builtInRegistry, ...options.registry };
+    const rootBase = "https://toolcraft.invalid/root";
+    function validationVocabularyFor(schemaObject) {
+        const metaSchema = schemaObject.$schema;
+        if (typeof metaSchema !== "string") {
+            return true;
+        }
+        const registered = registry[metaSchema];
+        if (!isObject(registered) || !isObject(registered.$vocabulary)) {
+            return true;
+        }
+        return Object.prototype.hasOwnProperty.call(registered.$vocabulary, "https://json-schema.org/draft/2020-12/vocab/validation");
+    }
+    function recordNode(schemaObject, node) {
+        if (schemaObject === undefined) {
+            return;
+        }
+        const nodes = nodesBySchema.get(schemaObject) ?? [];
+        nodes.push(node);
+        nodesBySchema.set(schemaObject, nodes);
+    }
+    function setLocation(dialect, uri, node) {
+        locations.set(mapKey(dialect, uri), node);
+    }
+    function scan(currentSchema, inheritedDialect, inheritedBase, resourceRoot, pointer, validationVocabulary, documentId) {
+        const schemaObject = isObject(currentSchema) ? currentSchema : undefined;
+        const dialect = schemaObject === undefined ? inheritedDialect : dialectFor(schemaObject, inheritedDialect);
+        if (schemaObject !== undefined) {
+            validateSchemaObject(schemaObject, dialect);
+        }
+        const declaredId = dialect === "draft7" ? (schemaObject?.$id ?? schemaObject?.id) : schemaObject?.$id;
+        const effectiveId = dialect === "draft7" && typeof schemaObject?.$ref === "string" ? undefined : declaredId;
+        const baseUri = typeof effectiveId === "string" ? resolveUri(effectiveId, inheritedBase) : inheritedBase;
+        const node = {
+            schema: currentSchema,
+            documentId,
+            dialect,
+            baseUri,
+            resourceUri: resourceRoot?.resourceUri ?? withoutFragment(baseUri),
+            resourceRoot: undefined,
+            pointer,
+            validationVocabulary,
+            children: new Map()
+        };
+        recordNode(schemaObject, node);
+        if (resourceRoot !== undefined) {
+            setLocation(resourceRoot.dialect, resolveUri(`#${encodeURI(pointer)}`, resourceRoot.resourceUri), node);
+        }
+        const startsResource = resourceRoot === undefined || withoutFragment(baseUri) !== resourceRoot.resourceUri;
+        node.resourceRoot = startsResource ? node : resourceRoot;
+        node.resourceUri = startsResource ? withoutFragment(baseUri) : resourceRoot.resourceUri;
+        const resourcePointer = startsResource ? "" : pointer;
+        node.pointer = resourcePointer;
+        if (startsResource) {
+            resources.set(mapKey(node.dialect, node.resourceUri), node);
+            setLocation(node.dialect, node.resourceUri, node);
+        }
+        setLocation(node.dialect, resolveUri(`#${encodeURI(resourcePointer)}`, node.resourceUri), node);
+        if (schemaObject === undefined) {
+            return node;
+        }
+        if (typeof schemaObject.$anchor === "string") {
+            anchors.set(mapKey(node.dialect, `${node.resourceUri}#${schemaObject.$anchor}`), node);
+        }
+        if (typeof schemaObject.$dynamicAnchor === "string") {
+            const anchorUri = `${node.resourceUri}#${schemaObject.$dynamicAnchor}`;
+            anchors.set(mapKey(node.dialect, anchorUri), node);
+            dynamicAnchors.set(mapKey(node.dialect, anchorUri), node);
+        }
+        if (dialect === "draft7" && typeof effectiveId === "string" && fragmentOf(baseUri) !== "") {
+            anchors.set(mapKey(dialect, baseUri), node);
+        }
+        for (const keyword of ["$ref", "$dynamicRef", "$recursiveRef"]) {
+            const reference = schemaObject[keyword];
+            if (reference !== undefined) {
+                if (typeof reference !== "string") {
+                    throw new Error(`${keyword} must be a string.`);
+                }
+                pendingReferences.push({ node, reference });
+            }
+        }
+        if (typeof schemaObject.pattern === "string") {
+            new RegExp(schemaObject.pattern, "u");
+        }
+        if (isObject(schemaObject.patternProperties)) {
+            for (const pattern of Object.keys(schemaObject.patternProperties)) {
+                new RegExp(pattern, "u");
+            }
+        }
+        const nextValidationVocabulary = resourceRoot === undefined ? validationVocabularyFor(schemaObject) : validationVocabulary;
+        for (const [keyword, value] of Object.entries(schemaObject)) {
+            if (schemaMapKeywords.has(keyword) && isObject(value)) {
+                for (const [key, childSchema] of Object.entries(value)) {
+                    if (isSchema(childSchema)) {
+                        node.children.set(`${keyword}/${key}`, scan(childSchema, dialect, baseUri, node.resourceRoot, `${resourcePointer}/${escapePointer(keyword)}/${escapePointer(key)}`, nextValidationVocabulary, documentId));
+                    }
+                }
+            }
+            else if (schemaArrayKeywords.has(keyword) && Array.isArray(value)) {
+                value.forEach((childSchema, index) => {
+                    if (isSchema(childSchema)) {
+                        node.children.set(`${keyword}/${index}`, scan(childSchema, dialect, baseUri, node.resourceRoot, `${resourcePointer}/${escapePointer(keyword)}/${index}`, nextValidationVocabulary, documentId));
+                    }
+                });
+            }
+            else if (schemaKeywords.has(keyword)) {
+                if (keyword === "items" && Array.isArray(value)) {
+                    value.forEach((childSchema, index) => {
+                        if (isSchema(childSchema)) {
+                            node.children.set(`items/${index}`, scan(childSchema, dialect, baseUri, node.resourceRoot, `${resourcePointer}/items/${index}`, nextValidationVocabulary, documentId));
+                        }
+                    });
+                }
+                else if (isSchema(value)) {
+                    node.children.set(keyword, scan(value, dialect, baseUri, node.resourceRoot, `${resourcePointer}/${escapePointer(keyword)}`, nextValidationVocabulary, documentId));
+                }
+            }
+        }
+        return node;
+    }
+    const root = scan(schema, "draft2020-12", rootBase, undefined, "", true, "root");
+    resources.set(mapKey(root.dialect, rootBase), root);
+    setLocation(root.dialect, rootBase, root);
+    setLocation(root.dialect, `${rootBase}#`, root);
+    for (const [uri, registeredSchema] of Object.entries(registry)) {
+        if (!isSchema(registeredSchema)) {
+            throw new Error(`Registered JSON Schema ${uri} must be a boolean or object.`);
+        }
+        for (const inheritedDialect of ["draft2020-12", "draft7"]) {
+            const remote = scan(registeredSchema, inheritedDialect, uri, undefined, "", true, `${inheritedDialect}:${uri}`);
+            resources.set(mapKey(remote.dialect, withoutFragment(uri)), remote);
+            setLocation(remote.dialect, withoutFragment(uri), remote);
+            setLocation(remote.dialect, `${withoutFragment(uri)}#`, remote);
+        }
+    }
+    function findByDialect(map, dialect, uri) {
+        const alternate = dialect === "draft7" ? "draft2020-12" : "draft7";
+        return map.get(mapKey(dialect, uri)) ?? map.get(mapKey(alternate, uri));
+    }
+    function resolve(node, reference) {
+        const absolute = resolveUri(reference, node.baseUri);
+        const direct = findByDialect(locations, node.dialect, absolute) ??
+            findByDialect(resources, node.dialect, absolute) ??
+            findByDialect(anchors, node.dialect, absolute);
+        if (direct !== undefined) {
+            return direct;
+        }
+        const resource = findByDialect(resources, node.dialect, withoutFragment(absolute));
+        const fragment = fragmentOf(absolute);
+        if (resource !== undefined && fragment === "") {
+            return resource;
+        }
+        if (fragment.startsWith("/")) {
+            const pointerTarget = findByDialect(locations, node.dialect, `${withoutFragment(absolute)}#${fragment}`);
+            if (pointerTarget !== undefined) {
+                return pointerTarget;
+            }
+            if (resource !== undefined && isObject(resource.schema)) {
+                let target = resource.schema;
+                for (const segment of fragment.slice(1).split("/")) {
+                    if (!isObject(target) && !Array.isArray(target)) {
+                        target = undefined;
+                        break;
+                    }
+                    const key = decodeURIComponent(segment).replaceAll("~1", "/").replaceAll("~0", "~");
+                    target = Array.isArray(target) ? target[Number(key)] : target[key];
+                }
+                if (isObject(target)) {
+                    const targetNode = nodesBySchema
+                        .get(target)
+                        ?.find((candidate) => candidate.dialect === node.dialect);
+                    if (targetNode !== undefined) {
+                        return targetNode;
+                    }
+                }
+            }
+        }
+        throw new Error(`Unresolvable $ref: ${reference}`);
+    }
+    const reachableDocuments = new Set([root.documentId]);
+    let discoveredDocument = true;
+    while (discoveredDocument) {
+        discoveredDocument = false;
+        for (const pending of pendingReferences) {
+            if (!reachableDocuments.has(pending.node.documentId)) {
+                continue;
+            }
+            const target = resolve(pending.node, pending.reference);
+            if (!reachableDocuments.has(target.documentId)) {
+                reachableDocuments.add(target.documentId);
+                discoveredDocument = true;
+            }
+        }
+    }
+    return {
+        root,
+        locations,
+        resources,
+        anchors,
+        dynamicAnchors,
+        resolve,
+        dynamicAnchor(scope, name) {
+            return dynamicAnchors.get(mapKey(scope.dialect, `${scope.resourceUri}#${name}`));
+        }
+    };
+}

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

@@ -0,0 +1,3 @@
+import type { CompiledGraph } from "./compiler.js";
+import type { EvaluationResult } from "./types.js";
+export declare function evaluateSchema(graph: CompiledGraph, value: unknown): EvaluationResult;