argsbarg 7.1.2 → 7.1.3

package/src/cli-tool/schemagen/run.ts

@@ -5,6 +5,7 @@ Generate JSON Schema artifacts under __generated__/ and write index.ts re-export
 import { mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join, relative } from "node:path";
 import { createGenerator } from "ts-json-schema-generator";
+import { resolveJsonPointer } from "../../core/json-pointer.ts";
 import { cleanStaleGenerated } from "./cleanup.ts";
 import { discoverSchemaRoots, type SchemaRoot } from "./discover-schema-roots.ts";
 import { GENERATED_DIR, schemaExportName, schemaJsonBasename, schemaJsonImportVar } from "./names.ts";
@@ -46,11 +47,49 @@ function generateJson(projectRoot: string, tsconfigPath: string, root: SchemaRoo
     jsDoc: "extended",
     additionalProperties: false,
   });
-  const schema = generator.createSchema(root.typeName) as Record<string, unknown>;
-  schema.additionalProperties = false;
+  const schema = hoistRootRef(generator.createSchema(root.typeName) as Record<string, unknown>, root.typeName);
+  // Only object roots: on a union root with no root `properties`, this would reject every property.
+  if (schema.type === "object") {
+    schema.additionalProperties = false;
+  }
   return schema;
 }
 
+/**
+ * Replaces a root `$ref` with the definition it names, following alias chains
+ * (`export type Input = Inner` emits `{ $ref: "#/definitions/Inner" }` even with `topRef: false`).
+ * Keeps `definitions` so nested and recursive references still resolve.
+ */
+function hoistRootRef(
+  /** Schema from ts-json-schema-generator. */
+  schema: Record<string, unknown>,
+  /** Root type name, for error messages. */
+  typeName: string,
+): Record<string, unknown> {
+  let target = schema;
+  const seen = new Set<string>();
+  while (typeof target.$ref === "string") {
+    const ref = target.$ref;
+    if (seen.has(ref)) {
+      throw new Error(`schemagen: ${typeName} root $ref cycle at ${ref}`);
+    }
+    seen.add(ref);
+    const next = resolveJsonPointer(schema, ref);
+    if (typeof next !== "object" || next === null || Array.isArray(next)) {
+      throw new Error(`schemagen: ${typeName} root $ref does not resolve: ${ref}`);
+    }
+    target = next as Record<string, unknown>;
+  }
+  if (target === schema) {
+    return schema;
+  }
+  return {
+    ...(schema.$schema === undefined ? {} : { $schema: schema.$schema }),
+    ...target,
+    ...(schema.definitions === undefined ? {} : { definitions: schema.definitions }),
+  };
+}
+
 function writeGeneratedIndex(generatedDir: string, roots: SchemaRoot[]): void {
   const sorted = [...roots].sort((left, right) => left.typeName.localeCompare(right.typeName));
   const lines = ["// Auto-generated by argsbarg schemagen — do not edit by hand.", ""];

package/src/cli-tool/schemagen/schemagen.test.ts

@@ -48,7 +48,12 @@ function writeSrcFile(root: string, relPath: string, body: string): void {
 describe("schemagen", () => {
   test("discovers @sg types in full-example-json", () => {
     const roots = discoverSchemaRoots(exampleRoot);
-    expect(roots.map((r) => r.typeName).sort()).toEqual(["RenderJsonInput", "StatusJsonOutput", "WorkspaceNameInput"]);
+    expect(roots.map((r) => r.typeName).sort()).toEqual([
+      "RenderJsonInput",
+      "ShapeAreaInput",
+      "StatusJsonOutput",
+      "WorkspaceNameInput",
+    ]);
   });
 
   test("maps type names to __generated__ filenames and export names", () => {
@@ -58,7 +63,7 @@ describe("schemagen", () => {
 
   test("runSchemagen writes __generated__ artifacts in full-example-json", () => {
     const counts = runSchemagen({ projectRoot: exampleRoot });
-    expect(counts).toEqual({ schemas: 3 });
+    expect(counts).toEqual({ schemas: 4 });
   });
 
   test("discovers @sg roots and writes named schema artifacts", () => {
@@ -230,4 +235,84 @@ export interface DupType {
 
     expect(() => discoverSchemaRoots(root)).toThrow("duplicate schema root type DupType");
   });
+
+  describe("root normalization", () => {
+    /** Writes one `@sg` type (plus helper types) and returns its generated schema. */
+    function generate(typeName: string, body: string): Record<string, unknown> {
+      const root = makeTempProject();
+      writeSrcFile(root, "src/commands/demo/types.ts", body);
+      runSchemagen({ projectRoot: root });
+      const path = join(root, "src/commands/demo/__generated__", schemaJsonBasename(typeName));
+      return JSON.parse(readFileSync(path, "utf8")) as Record<string, unknown>;
+    }
+
+    test("hoists an alias root $ref to an object root", () => {
+      const schema = generate(
+        "AliasInput",
+        `export interface Inner {
+  name: string;
+}
+/** @sg */
+export type AliasInput = Inner;
+`,
+      );
+      expect(schema.$ref).toBeUndefined();
+      expect(schema.type).toBe("object");
+      expect(schema.properties).toEqual({ name: { type: "string" } });
+      expect(schema.additionalProperties).toBe(false);
+    });
+
+    test("follows alias chains and percent-encoded generic refs", () => {
+      const chain = generate(
+        "ChainInput",
+        `export interface Inner {
+  name: string;
+}
+export type Mid = Inner;
+/** @sg */
+export type ChainInput = Mid;
+`,
+      );
+      expect(chain.type).toBe("object");
+      expect(chain.properties).toEqual({ name: { type: "string" } });
+
+      const generic = generate(
+        "GenericInput",
+        `export interface Box<T> {
+  value: T;
+}
+/** @sg */
+export type GenericInput = Box<string>;
+`,
+      );
+      expect(generic.type).toBe("object");
+      expect(generic.properties).toEqual({ value: { type: "string" } });
+    });
+
+    test("keeps definitions so recursive references still resolve", () => {
+      const schema = generate(
+        "TreeInput",
+        `export interface Tree {
+  name: string;
+  children?: Tree[];
+}
+/** @sg */
+export type TreeInput = Tree;
+`,
+      );
+      expect(schema.type).toBe("object");
+      expect((schema.definitions as Record<string, unknown>).Tree).toBeDefined();
+    });
+
+    test("leaves union roots without a root additionalProperties", () => {
+      const schema = generate(
+        "UnionInput",
+        `/** @sg */
+export type UnionInput = { kind: "a"; a: string } | { kind: "b"; b: number };
+`,
+      );
+      expect(Array.isArray(schema.anyOf)).toBe(true);
+      expect(schema.additionalProperties).toBeUndefined();
+    });
+  });
 });

package/src/config/validate.ts

@@ -5,6 +5,7 @@ CLI value coercion for configure set remains here (comma-separated arrays, boole
 
 import { format as jsonSchemaFormats, type Schema, type SchemaDraft, Validator } from "@cfworker/json-schema";
 import { parseCommaList, parseDate, parseDateTime, validateCommaList } from "../core/formats.ts";
+import { decodeJsonPointerSegment, resolveJsonPointer } from "../core/json-pointer.ts";
 import { isFrameworkConfigKey } from "./bindings.ts";
 
 type JsonSchema = Record<string, unknown>;
@@ -72,10 +73,6 @@ function formatInstancePath(instanceLocation: string): string {
   return instanceLocation;
 }
 
-function decodeJsonPointerSegment(segment: string): string {
-  return segment.replace(/~1/g, "/").replace(/~0/g, "~");
-}
-
 /** cfworker keywords that only wrap a deeper, more specific failure — dropped when one survives underneath. */
 const WRAPPER_KEYWORDS = new Set([
   "$ref",
@@ -235,8 +232,12 @@ function unionDiscriminator(branches: unknown[], root: JsonSchema): UnionDiscrim
   if (eligible.length === 0) {
     return undefined;
   }
-  const prop = eligible.includes("kind") ? "kind" : eligible.includes("type") ? "type" : [...eligible].sort()[0]!;
-  return { prop, valuesByBranch: branchValuesFor(prop)! };
+  const prop = eligible.includes("kind") ? "kind" : eligible.includes("type") ? "type" : [...eligible].sort()[0];
+  const valuesByBranch = prop === undefined ? undefined : branchValuesFor(prop);
+  if (prop === undefined || valuesByBranch === undefined) {
+    return undefined;
+  }
+  return { prop, valuesByBranch };
 }
 
 /** Sorted, comma-joined, unquoted list of values for error messages. */
@@ -248,7 +249,7 @@ function joinSorted(values: Iterable<string>): string {
 function rewriteErrorMessage(err: RawError, root: JsonSchema): string {
   const additionalPropsMatch = /^Property "(.+)" does not match additional properties schema\.$/.exec(err.error);
   if (additionalPropsMatch) {
-    const name = additionalPropsMatch[1]!;
+    const name = additionalPropsMatch[1] ?? "";
     const parentLoc = parentPointer(err.keywordLocation);
     const parentSchema = parentLoc ? schemaAtPointer(root, parentLoc) : undefined;
     const props =
@@ -268,7 +269,7 @@ function rewriteErrorMessage(err: RawError, root: JsonSchema): string {
   const enumMatch = /^Instance does not match any of (\[.*\])\.$/.exec(err.error);
   if (enumMatch) {
     try {
-      const values = JSON.parse(enumMatch[1]!) as unknown[];
+      const values = JSON.parse(enumMatch[1] ?? "") as unknown[];
       return `must be one of: ${values.map((v) => String(v)).join(", ")}`;
     } catch {
       // fall through to the raw message
@@ -394,16 +395,16 @@ function narrowUnionErrors(errors: RawError[], root: JsonSchema, data: unknown):
   for (const err of errors) {
     if (dropped.has(err)) continue;
     if (err.keyword === "additionalProperties") {
-      const match = /^Property "(.+)" does not match additional properties schema\.$/.exec(err.error);
+      const name = /^Property "(.+)" does not match additional properties schema\.$/.exec(err.error)?.[1];
       const parentLoc = parentPointer(err.keywordLocation);
       const parentSchema = parentLoc ? schemaAtPointer(root, parentLoc) : undefined;
       const props =
-        match && parentSchema && typeof parentSchema === "object" && !Array.isArray(parentSchema)
+        name !== undefined && parentSchema && typeof parentSchema === "object" && !Array.isArray(parentSchema)
           ? (parentSchema as JsonSchema).properties
           : undefined;
       const declared =
-        match && props && typeof props === "object" && !Array.isArray(props)
-          ? Object.hasOwn(props as JsonSchema, match[1]!)
+        name !== undefined && props && typeof props === "object" && !Array.isArray(props)
+          ? Object.hasOwn(props as JsonSchema, name)
           : false;
       if (declared) dropped.add(err);
       continue;
@@ -450,25 +451,6 @@ export function resolveSchemaDraft(schema: JsonSchema): SchemaDraft {
   return "7";
 }
 
-function resolveJsonPointer(root: JsonSchema, ref: string): unknown {
-  if (!ref.startsWith("#/")) {
-    return undefined;
-  }
-  const segments = ref
-    .slice(2)
-    .split("/")
-    .filter((segment) => segment.length > 0)
-    .map(decodeJsonPointerSegment);
-  let current: unknown = root;
-  for (const segment of segments) {
-    if (typeof current !== "object" || current === null || Array.isArray(current)) {
-      return undefined;
-    }
-    current = (current as Record<string, unknown>)[segment];
-  }
-  return current;
-}
-
 function attachRootCompanionSchemas(validator: Validator, root: JsonSchema, active: JsonSchema): void {
   if (active === root) {
     return;

package/src/core/json-pointer.ts

@@ -0,0 +1,46 @@
+/*
+Same-document JSON Pointer resolution for JSON Schema `$ref` values (`#/definitions/Foo`).
+Shared by schemagen root hoisting, MCP tool schema checks, config validation, and OpenAPI dereferencing.
+*/
+
+/**
+ * Decodes one JSON Pointer segment: URI percent-escapes first (ts-json-schema-generator writes
+ * `#/definitions/Box%3Cstring%3E`), then the `~1` → `/` and `~0` → `~` pointer escapes.
+ */
+export function decodeJsonPointerSegment(
+  /** Raw segment between `/` separators. */
+  segment: string,
+): string {
+  let decoded = segment;
+  try {
+    decoded = decodeURIComponent(segment);
+  } catch {
+    // Malformed percent-escape: fall back to the raw segment.
+  }
+  return decoded.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+
+/** Resolves a same-document JSON Pointer (`#/definitions/Foo`) against `root`; `undefined` when it does not resolve. */
+export function resolveJsonPointer(
+  /** Document the pointer is resolved against (the schema root). */
+  root: unknown,
+  /** `$ref` value; only `#/…` pointers are resolved. */
+  ref: string,
+): unknown {
+  if (!ref.startsWith("#/")) {
+    return undefined;
+  }
+  const segments = ref
+    .slice(2)
+    .split("/")
+    .filter((segment) => segment.length > 0)
+    .map(decodeJsonPointerSegment);
+  let current: unknown = root;
+  for (const segment of segments) {
+    if (typeof current !== "object" || current === null || Array.isArray(current)) {
+      return undefined;
+    }
+    current = (current as Record<string, unknown>)[segment];
+  }
+  return current;
+}

package/src/core/validate.ts

@@ -5,9 +5,10 @@ This module validates CLI schemas before execution.
 import { reservedDocsTopicResourceUris } from "../docs/mcp-resources.ts";
 import { DOCS_BUILTIN_TOPIC_KEYS, docsEnabled } from "../docs/resolve.ts";
 import { HTTP_RESERVED_TOP_LEVEL_SEGMENTS } from "../http/paths.ts";
-import { resolveMcpSchemaUri } from "../mcp/tools.ts";
+import { collectMcpTools, resolveMcpSchemaUri } from "../mcp/tools.ts";
 import { reservedCommandNames, resolveCapabilities } from "../runtime/capabilities.ts";
 import { validateFormatValue } from "./formats.ts";
+import { resolveJsonPointer } from "./json-pointer.ts";
 import {
   type CliLeaf,
   type CliNode,
@@ -196,6 +197,68 @@ export function cliValidateProgram(program: CliProgram): void {
   }
 
   walkNode(program, program, true);
+
+  if (caps.mcp) {
+    validateMcpToolSchemas(program);
+  }
+}
+
+/** Keywords whose values are instance data, not subschemas; a `$ref` string inside them is not a reference. */
+const SCHEMA_DATA_KEYWORDS = new Set(["const", "default", "enum", "examples"]);
+
+/** Collects every `$ref` string in a schema (skipping instance-data keywords). */
+function collectSchemaRefs(
+  /** Schema fragment to walk. */
+  node: unknown,
+  /** Accumulator for found `$ref` values. */
+  out: string[],
+): string[] {
+  if (Array.isArray(node)) {
+    for (const item of node) {
+      collectSchemaRefs(item, out);
+    }
+  } else if (typeof node === "object" && node !== null) {
+    for (const [key, value] of Object.entries(node)) {
+      if (key === "$ref" && typeof value === "string") {
+        out.push(value);
+      } else if (!SCHEMA_DATA_KEYWORDS.has(key)) {
+        collectSchemaRefs(value, out);
+      }
+    }
+  }
+  return out;
+}
+
+/**
+ * Checks the schemas MCP clients will see (after object-root wrapping in `collectMcpTools`):
+ * every local `$ref` must resolve, and wrapped schemas cannot use `$ref: "#"` (it would point at the wrapper).
+ */
+function validateMcpToolSchemas(
+  /** Program with `mcpServer.enabled`. */
+  program: CliProgram,
+): void {
+  for (const tool of collectMcpTools(program)) {
+    const schemas = [
+      { label: "inputSchema", schema: tool.inputSchema, wrapped: tool.inputWrapped },
+      { label: "outputSchema", schema: tool.outputSchema, wrapped: tool.outputWrapped },
+    ];
+    for (const { label, schema, wrapped } of schemas) {
+      if (schema === undefined) {
+        continue;
+      }
+      for (const ref of collectSchemaRefs(schema, [])) {
+        if (ref === "#" && wrapped) {
+          throw new CliSchemaValidationError(
+            `MCP tool "${tool.name}" ${label} uses $ref "#" but its root is not type "object", so MCP wraps it; ` +
+              "reference a named definition instead",
+          );
+        }
+        if (ref.startsWith("#/") && resolveJsonPointer(schema, ref) === undefined) {
+          throw new CliSchemaValidationError(`MCP tool "${tool.name}" ${label} has an unresolved $ref: ${ref}`);
+        }
+      }
+    }
+  }
 }
 
 const PARAM_ROUTER_KEY = /^:[a-zA-Z][a-zA-Z0-9_]*$/;

package/src/headless/tool-call.test.ts

@@ -1,7 +1,15 @@
-/* Unit tests for shared headless error text (MCP and HTTP). */
+/* Unit tests for shared headless error text (MCP and HTTP) and wrapped MCP tool calls. */
 
 import { describe, expect, test } from "bun:test";
-import { type HeadlessToolCallFailure, headlessFailureMcpMessage, headlessFailureToHttpResponse } from "./tool-call.ts";
+import { Cli, type CliContext } from "../index.ts";
+import { collectMcpTools } from "../mcp/tools.ts";
+import { requireMcpTool, testProgram } from "../test/fixtures.ts";
+import {
+  executeHeadlessToolCall,
+  type HeadlessToolCallFailure,
+  headlessFailureMcpMessage,
+  headlessFailureToHttpResponse,
+} from "./tool-call.ts";
 
 /** Builds a failed headless result with the given error message. */
 function invokeFailure(
@@ -30,3 +38,67 @@ describe("headless error text", () => {
     expect(body.error).toBe(multiline);
   });
 });
+
+describe("wrapped MCP tools", () => {
+  /** Union input leaf that echoes its inputs; output is an array so structuredContent gets wrapped too. */
+  const program = testProgram({
+    key: "wrapcall",
+    description: "Wrapped call demo.",
+    mcpServer: { enabled: true },
+    commands: [
+      {
+        key: "edit",
+        description: "Edit.",
+        kind: "document",
+        inputSchema: {
+          anyOf: [{ $ref: "#/definitions/Append" }, { $ref: "#/definitions/Replace" }],
+          definitions: {
+            Append: {
+              type: "object",
+              properties: { kind: { const: "append" }, text: { type: "string" } },
+              required: ["kind", "text"],
+              additionalProperties: false,
+            },
+            Replace: {
+              type: "object",
+              properties: { kind: { const: "replace" }, find: { type: "string" }, text: { type: "string" } },
+              required: ["kind", "find", "text"],
+              additionalProperties: false,
+            },
+          },
+        },
+        outputSchema: { type: "array" },
+        handler: (ctx: CliContext) => [ctx.inputs],
+      },
+    ],
+  });
+  const cli = new Cli(program);
+  const tool = requireMcpTool(collectMcpTools(program), "edit");
+
+  test("unwraps input and wraps structuredContent under result", async () => {
+    const result = await executeHeadlessToolCall(cli, tool, { input: { kind: "append", text: "hi" } }, "mcp");
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.mcpResult.structuredContent).toEqual({ result: [{ kind: "append", text: "hi" }] });
+    }
+  });
+
+  test("still validates the exact union after unwrapping", async () => {
+    const result = await executeHeadlessToolCall(
+      cli,
+      tool,
+      { input: { kind: "append", text: "hi", find: "x" } },
+      "mcp",
+    );
+    expect(result.ok).toBe(false);
+  });
+
+  test("rejects arguments that are not wrapped", async () => {
+    const result = await executeHeadlessToolCall(cli, tool, { kind: "append", text: "hi" }, "mcp");
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.kind).toBe("argv");
+      expect(result.message).toContain('single "input" object property');
+    }
+  });
+});

package/src/headless/tool-call.ts

@@ -10,7 +10,13 @@ import { apiErrorResponse, apiSuccessResponse, stripAnsi } from "../http/result.
 import { type HttpRouteDef, httpRequestToArgv } from "../http/routes.ts";
 import { obscureUnexpectedClientMessage } from "../log/emitter.ts";
 import { buildToolCallSuccessFromResponse } from "../mcp/result.ts";
-import { collectMcpTools, type McpToolDef, mcpToolCallToArgv } from "../mcp/tools.ts";
+import {
+  collectMcpTools,
+  MCP_INPUT_WRAPPER_KEY,
+  MCP_OUTPUT_WRAPPER_KEY,
+  type McpToolDef,
+  mcpToolCallToArgv,
+} from "../mcp/tools.ts";
 import type { Cli, CliInvokeResult } from "../runtime/cli.ts";
 
 /** Outcome of resolving a tool name against the program schema. */
@@ -86,8 +92,31 @@ function noResponseFailure(result: CliInvokeResult): HeadlessToolCallFailure {
   };
 }
 
+/** Pre-invoke argument failure (bad shape or argv conversion error). */
+function argvFailure(
+  /** Client-facing error message. */
+  message: string,
+): HeadlessToolCallFailure {
+  return { ok: false, kind: "argv", message, exitCode: 1, stdout: "", stderr: "", failureKind: "validation" };
+}
+
+/** Returns the leaf input from wrapped tool arguments (`{ input: {...} }`), or `undefined` when malformed. */
+function unwrapToolArgs(
+  /** Raw tools/call arguments. */
+  args: Record<string, unknown>,
+): Record<string, unknown> | undefined {
+  const inner = args[MCP_INPUT_WRAPPER_KEY];
+  const onlyWrapperKey = Object.keys(args).every((key) => key === MCP_INPUT_WRAPPER_KEY);
+  if (!onlyWrapperKey || typeof inner !== "object" || inner === null || Array.isArray(inner)) {
+    return undefined;
+  }
+  return inner as Record<string, unknown>;
+}
+
 /**
  * Converts flat tool arguments to argv and invokes the leaf handler headlessly.
+ * Wrapped tools (see `wrapMcpRootSchema`) receive `{ input: {...} }`, unwrapped here, and return
+ * `structuredContent` wrapped as `{ result: ... }` to match their `outputSchema`.
  */
 export async function executeHeadlessToolCall(
   cli: Cli,
@@ -96,20 +125,19 @@ export async function executeHeadlessToolCall(
   invocation: CliInvocation,
   mcp?: { rpcMethod: string; toolName?: string; requestId: string },
 ): Promise<HeadlessToolCallResult> {
-  const argvResult = mcpToolCallToArgv(cli.program, tool, args);
+  const leafArgs = tool.inputWrapped ? unwrapToolArgs(args) : args;
+  if (leafArgs === undefined) {
+    return argvFailure(
+      `Tool arguments must be an object with a single "${MCP_INPUT_WRAPPER_KEY}" object property (see inputSchema)`,
+    );
+  }
+
+  const argvResult = mcpToolCallToArgv(cli.program, tool, leafArgs);
   if ("error" in argvResult) {
-    return {
-      ok: false,
-      kind: "argv",
-      message: argvResult.error,
-      exitCode: 1,
-      stdout: "",
-      stderr: "",
-      failureKind: "validation",
-    };
+    return argvFailure(argvResult.error);
   }
 
-  const invokeResult = await cli.invoke(argvResult, { invocation, toolArgs: args, mcp });
+  const invokeResult = await cli.invoke(argvResult, { invocation, toolArgs: leafArgs, mcp });
   if (invokeResult.kind === "help") {
     return invokeFailure(invokeResult);
   }
@@ -119,7 +147,9 @@ export async function executeHeadlessToolCall(
     return {
       ok: true,
       response: invokeResult.response,
-      mcpResult,
+      mcpResult: tool.outputWrapped
+        ? { ...mcpResult, structuredContent: { [MCP_OUTPUT_WRAPPER_KEY]: mcpResult.structuredContent } }
+        : mcpResult,
     };
   }
 
@@ -143,15 +173,7 @@ export async function executeHttpRouteCall(
 ): Promise<HeadlessToolCallResult> {
   const argvResult = httpRequestToArgv(cli.program, route, pathParams, query, body);
   if ("error" in argvResult) {
-    return {
-      ok: false,
-      kind: "argv",
-      message: argvResult.error,
-      exitCode: 1,
-      stdout: "",
-      stderr: "",
-      failureKind: "validation",
-    };
+    return argvFailure(argvResult.error);
   }
 
   const toolArgs = { ...body, ...query, ...pathParams };

package/src/http/schema-deref.ts

@@ -2,34 +2,12 @@
 Inline JSON Schema $ref dereferencing for OpenAPI embedding.
 */
 
-function decodeJsonPointerSegment(segment: string): string {
-  return segment.replace(/~1/g, "/").replace(/~0/g, "~");
-}
+import { resolveJsonPointer } from "../core/json-pointer.ts";
 
 function isPlainObject(value: unknown): value is Record<string, unknown> {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 
-/** Resolves a same-document JSON Pointer (`#/definitions/Foo`). */
-function resolveJsonPointer(root: Record<string, unknown>, ref: string): unknown {
-  if (!ref.startsWith("#/")) {
-    return undefined;
-  }
-  const segments = ref
-    .slice(2)
-    .split("/")
-    .filter((segment) => segment.length > 0)
-    .map(decodeJsonPointerSegment);
-  let current: unknown = root;
-  for (const segment of segments) {
-    if (!isPlainObject(current)) {
-      return undefined;
-    }
-    current = current[segment];
-  }
-  return current;
-}
-
 function derefValue(value: unknown, root: Record<string, unknown>, resolving: Set<string>): unknown {
   if (Array.isArray(value)) {
     return value.map((item) => derefValue(item, root, resolving));