@cartanova/qgrid-cli 2.7.0 → 2.7.1

package/bundle/dist/application/qgrid/schema-prompt.js

@@ -0,0 +1,240 @@
+//#region src/application/qgrid/schema-prompt.ts
+/**
+* system prompt 말미에 계약을 덧붙인다. anthropic 은 cold-only(매 턴 CC 재스폰 + system
+* 재전송)라 멀티턴에도 계약이 매 턴 일관되게 주입된다. system 이 argv 64KB 를 넘으면
+* claude-session 의 --system-prompt-file 분기가 흡수한다.
+*/
+function composeSystemWithSchemaContract(system, input) {
+	const contract = renderSchemaContractPrompt(input);
+	if (contract === void 0) return system;
+	return system ? `${system}\n\n${contract}` : contract;
+}
+/** 요청에 스키마/tools 가 없으면 undefined — 계약 주입 없이 평범한 텍스트 요청이다. */
+function renderSchemaContractPrompt(input) {
+	if (input.tools?.length) return renderToolEnvelopePrompt(input.tools, input.jsonSchema);
+	if (input.jsonSchema !== void 0) return renderOutputSchemaPrompt(input.jsonSchema);
+}
+function renderOutputSchemaPrompt(jsonSchema) {
+	return [
+		"## Output Format",
+		"",
+		"Your entire reply must be a single JSON object that conforms to the JSON Schema below.",
+		"Output raw JSON only — no code fences, no prose before or after the JSON.",
+		"Start your reply with { and end it with }.",
+		"",
+		"<output-json-schema>",
+		jsonSchema,
+		"</output-json-schema>"
+	].join("\n");
+}
+/**
+* envelope 예시 JSON. 렌더 문구와 parseEnvelope 계약의 드리프트를 교차 테스트로 잡기
+* 위해 분리 export 한다 — 예시가 실제 파서를 통과하지 못하면 안내문이 틀린 것이다.
+*
+* 예시는 스스로 계약을 지켜야 한다: args 는 첫 tool 의 inputSchema 를 실제로 만족하는
+* 인스턴스여야 한다. 생성기가 다루지 못하는 keyword(pattern/$ref/allOf 등)가 스키마에
+* 있으면 **fail-closed** — 위반 가능성이 있는 예시를 싣는 대신 예시 자체를 생략하고
+* 렌더러가 프로즈 서술로 대체한다 (`toolCallExample: undefined`).
+*/
+function buildEnvelopeExamples(tools) {
+	const firstTool = tools[0];
+	const args = firstTool ? exampleValueForSchema(firstTool.inputSchema) : {
+		ok: true,
+		value: {}
+	};
+	return {
+		...args.ok ? { toolCallExample: JSON.stringify({ result: {
+			action: "tool_call",
+			answer: null,
+			toolCalls: [{
+				toolName: firstTool?.name ?? "toolName",
+				args: JSON.stringify(args.value)
+			}]
+		} }) } : {},
+		textAnswerExample: JSON.stringify({ result: {
+			action: "answer",
+			answer: "your final answer",
+			toolCalls: null
+		} })
+	};
+}
+/** 생성기가 값 선택에 반영하는 keyword. 어노테이션(description 등)은 값과 무관해 무시한다. */
+const EXAMPLE_ANNOTATION_KEYWORDS = /* @__PURE__ */ new Set([
+	"description",
+	"title",
+	"default",
+	"examples",
+	"$comment",
+	"deprecated",
+	"readOnly",
+	"writeOnly"
+]);
+const EXAMPLE_HANDLED_KEYWORDS = /* @__PURE__ */ new Set([
+	"type",
+	"enum",
+	"const",
+	"properties",
+	"required",
+	"additionalProperties",
+	"items",
+	"minItems",
+	"maxItems",
+	"minLength",
+	"maxLength",
+	"minimum",
+	"maximum",
+	"exclusiveMinimum",
+	"exclusiveMaximum",
+	"anyOf",
+	"oneOf"
+]);
+/**
+* inputSchema 를 만족하는 예시 인스턴스 생성. 지원 keyword 집합 밖의 제약
+* (pattern/format/$ref/allOf/not/if/multipleOf/uniqueItems/...)을 만나면 값을
+* 지어내지 않고 { ok: false } 를 돌려준다 — 계약 위반 예시는 모델이 베낀다.
+*/
+function exampleValueForSchema(schema) {
+	if (schema === true || schema === void 0) return {
+		ok: true,
+		value: {}
+	};
+	if (schema === null || typeof schema !== "object" || Array.isArray(schema)) return { ok: false };
+	const node = schema;
+	for (const keyword of Object.keys(node)) if (!EXAMPLE_HANDLED_KEYWORDS.has(keyword) && !EXAMPLE_ANNOTATION_KEYWORDS.has(keyword)) return { ok: false };
+	if (Array.isArray(node.enum) && node.enum.length > 0) return {
+		ok: true,
+		value: node.enum[0]
+	};
+	if ("const" in node) return {
+		ok: true,
+		value: node.const
+	};
+	for (const kw of ["anyOf", "oneOf"]) if (Array.isArray(node[kw])) {
+		const list = node[kw];
+		if (kw === "oneOf" && list.length > 1) return { ok: false };
+		for (const branch of list) {
+			const result = exampleValueForSchema(branch);
+			if (result.ok) return result;
+		}
+		return { ok: false };
+	}
+	switch (Array.isArray(node.type) ? node.type[0] : node.type) {
+		case "string": {
+			const min = typeof node.minLength === "number" ? node.minLength : 0;
+			if (min > 64) return { ok: false };
+			const base = "example";
+			const value = 7 >= min ? base : base.padEnd(min, "x");
+			if (typeof node.maxLength === "number" && value.length > node.maxLength) {
+				if (node.maxLength < min) return { ok: false };
+				return {
+					ok: true,
+					value: value.slice(0, node.maxLength)
+				};
+			}
+			return {
+				ok: true,
+				value
+			};
+		}
+		case "number":
+		case "integer": {
+			let value = 0;
+			if (typeof node.minimum === "number") value = node.minimum;
+			else if (typeof node.exclusiveMinimum === "number") value = node.exclusiveMinimum + 1;
+			if (typeof node.maximum === "number" && value > node.maximum) return { ok: false };
+			if (typeof node.exclusiveMaximum === "number" && value >= node.exclusiveMaximum) return { ok: false };
+			return {
+				ok: true,
+				value
+			};
+		}
+		case "boolean": return {
+			ok: true,
+			value: false
+		};
+		case "null": return {
+			ok: true,
+			value: null
+		};
+		case "array": {
+			const min = typeof node.minItems === "number" ? node.minItems : 0;
+			if (min > 8) return { ok: false };
+			if (typeof node.maxItems === "number" && node.maxItems < min) return { ok: false };
+			if (min === 0) return {
+				ok: true,
+				value: []
+			};
+			const item = exampleValueForSchema(node.items);
+			if (!item.ok) return { ok: false };
+			return {
+				ok: true,
+				value: Array.from({ length: min }, () => item.value)
+			};
+		}
+		case void 0:
+		case "object": {
+			const properties = node.properties && typeof node.properties === "object" && !Array.isArray(node.properties) ? node.properties : {};
+			const required = Array.isArray(node.required) ? node.required.filter((k) => typeof k === "string") : [];
+			const entries = [];
+			for (const key of required) {
+				const child = exampleValueForSchema(properties[key]);
+				if (!child.ok) return { ok: false };
+				entries.push([key, child.value]);
+			}
+			return {
+				ok: true,
+				value: Object.fromEntries(entries)
+			};
+		}
+		default: return { ok: false };
+	}
+}
+function renderToolEnvelopePrompt(tools, jsonSchema) {
+	const { toolCallExample, textAnswerExample } = buildEnvelopeExamples(tools);
+	const toolList = tools.map((tool) => {
+		const description = tool.description ? ` — ${tool.description}` : "";
+		return `- ${tool.name}${description}\n  inputSchema: ${JSON.stringify(tool.inputSchema)}`;
+	}).join("\n");
+	const answerVariant = jsonSchema === void 0 ? [
+		"2. Final answer — use only when no further client tool result is needed:",
+		textAnswerExample,
+		"- \"toolCalls\" must be null.",
+		"- \"answer\" must be a plain string with your final answer (not null)."
+	] : [
+		"2. Final answer — use only when no further client tool result is needed:",
+		"- Set \"action\" to \"answer\" and \"toolCalls\" to null.",
+		"- \"answer\" must be a JSON value (not null, and not a string of JSON) that conforms to the JSON Schema below.",
+		"",
+		"<answer-json-schema>",
+		jsonSchema,
+		"</answer-json-schema>"
+	];
+	return [
+		"## Client Tool Protocol",
+		"",
+		"The client-side tools listed below are executed by the client, which returns each result",
+		"in a follow-up turn. Do not invoke them as native Claude Code tools.",
+		"",
+		"Your entire reply must be a single JSON object of the form {\"result\": ...} —",
+		"raw JSON only, no code fences, no prose before or after the JSON.",
+		"The \"result\" value is exactly one of the two variants:",
+		"",
+		...[
+			toolCallExample !== void 0 ? "1. Request client-side tool execution, for example:" : "1. Request client-side tool execution:",
+			...toolCallExample !== void 0 ? [toolCallExample] : ["- Set \"action\" to \"tool_call\" and \"answer\" to null.", "- \"toolCalls\" is an array of objects, each {\"toolName\": ..., \"args\": ...}."],
+			"- \"toolCalls\" must contain at least one entry.",
+			"- \"toolName\" must be one of the client tool names listed below.",
+			"- \"args\" must be the tool arguments encoded as a JSON string (not an object), conforming to that tool's inputSchema.",
+			"- \"answer\" must be null."
+		],
+		"",
+		...answerVariant,
+		"",
+		"Available client tools:",
+		toolList
+	].join("\n");
+}
+//#endregion
+export { buildEnvelopeExamples, composeSystemWithSchemaContract, renderOutputSchemaPrompt, renderSchemaContractPrompt, renderToolEnvelopePrompt };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"schema-prompt.js","names":[],"sources":["../../../src/application/qgrid/schema-prompt.ts"],"sourcesContent":["/**\n * output schema / tool envelope 계약의 프롬프트 렌더링 (SON-532).\n *\n * anthropic 경로는 CC 에 --json-schema 를 전달하지 않는다 — 강제 없는 사후 채점(AJV)이\n * 소비자 의도와 충돌해 내부 재시도 루프를 만들었기 때문. 대신 여기서 계약을 텍스트로\n * 렌더해 system prompt 말미에 주입하고, 판정은 소비자 zod(스키마) / parseEnvelope\n * (envelope, tool-emulation.ts)가 맡는다.\n *\n * 원칙:\n * - user 스키마는 수신 원형 그대로 안내한다 — strictify(전 필드 required 강제,\n *   additionalProperties:false)를 거치지 않아 소비자의 nullish/optional 의도가 보존된다.\n * - envelope 은 buildToolCallSchema(tool-emulation-schema.ts)처럼 user 스키마를 $defs 로\n *   합성하지 않는다. 텍스트 안내라 `$ref` 문서 루트 충돌이 없어 rebase 가 불필요하고,\n *   그 덕에 rebase 가 거절하던 형태(named anchor $ref 등)도 그대로 통과한다.\n * - 렌더된 계약은 parseEnvelope 의 zod 계약({\"result\": ...} 한 겹, 상호배타 변형)과\n *   정확히 일치해야 한다 — 교차 테스트(schema-prompt.test.ts)가 드리프트를 막는다.\n */\nimport { type QgridTool, type QueryInput } from \"./qgrid.types\";\n\n/**\n * system prompt 말미에 계약을 덧붙인다. anthropic 은 cold-only(매 턴 CC 재스폰 + system\n * 재전송)라 멀티턴에도 계약이 매 턴 일관되게 주입된다. system 이 argv 64KB 를 넘으면\n * claude-session 의 --system-prompt-file 분기가 흡수한다.\n */\nexport function composeSystemWithSchemaContract(\n  system: string | undefined,\n  input: Pick<QueryInput, \"tools\" | \"jsonSchema\">,\n): string | undefined {\n  const contract = renderSchemaContractPrompt(input);\n  if (contract === undefined) return system;\n  return system ? `${system}\\n\\n${contract}` : contract;\n}\n\n/** 요청에 스키마/tools 가 없으면 undefined — 계약 주입 없이 평범한 텍스트 요청이다. */\nexport function renderSchemaContractPrompt(\n  input: Pick<QueryInput, \"tools\" | \"jsonSchema\">,\n): string | undefined {\n  if (input.tools?.length) {\n    return renderToolEnvelopePrompt(input.tools, input.jsonSchema);\n  }\n  if (input.jsonSchema !== undefined) {\n    return renderOutputSchemaPrompt(input.jsonSchema);\n  }\n  return undefined;\n}\n\n// 1091748 실측(스키마 원문 + \"펜스·설명 없이 JSON 만\" 지시)에서 검증된 형식을 따른다.\nexport function renderOutputSchemaPrompt(jsonSchema: string): string {\n  return [\n    \"## Output Format\",\n    \"\",\n    \"Your entire reply must be a single JSON object that conforms to the JSON Schema below.\",\n    \"Output raw JSON only — no code fences, no prose before or after the JSON.\",\n    \"Start your reply with { and end it with }.\",\n    \"\",\n    \"<output-json-schema>\",\n    jsonSchema,\n    \"</output-json-schema>\",\n  ].join(\"\\n\");\n}\n\n/**\n * envelope 예시 JSON. 렌더 문구와 parseEnvelope 계약의 드리프트를 교차 테스트로 잡기\n * 위해 분리 export 한다 — 예시가 실제 파서를 통과하지 못하면 안내문이 틀린 것이다.\n *\n * 예시는 스스로 계약을 지켜야 한다: args 는 첫 tool 의 inputSchema 를 실제로 만족하는\n * 인스턴스여야 한다. 생성기가 다루지 못하는 keyword(pattern/$ref/allOf 등)가 스키마에\n * 있으면 **fail-closed** — 위반 가능성이 있는 예시를 싣는 대신 예시 자체를 생략하고\n * 렌더러가 프로즈 서술로 대체한다 (`toolCallExample: undefined`).\n */\nexport function buildEnvelopeExamples(tools: QgridTool[]): {\n  toolCallExample?: string;\n  textAnswerExample: string;\n} {\n  const firstTool = tools[0];\n  const args = firstTool ? exampleValueForSchema(firstTool.inputSchema) : { ok: true, value: {} };\n  return {\n    ...(args.ok\n      ? {\n          toolCallExample: JSON.stringify({\n            result: {\n              action: \"tool_call\",\n              answer: null,\n              toolCalls: [\n                { toolName: firstTool?.name ?? \"toolName\", args: JSON.stringify(args.value) },\n              ],\n            },\n          }),\n        }\n      : {}),\n    textAnswerExample: JSON.stringify({\n      result: { action: \"answer\", answer: \"your final answer\", toolCalls: null },\n    }),\n  };\n}\n\ntype ExampleResult = { ok: true; value: unknown } | { ok: false };\n\n/** 생성기가 값 선택에 반영하는 keyword. 어노테이션(description 등)은 값과 무관해 무시한다. */\nconst EXAMPLE_ANNOTATION_KEYWORDS = new Set([\n  \"description\",\n  \"title\",\n  \"default\",\n  \"examples\",\n  \"$comment\",\n  \"deprecated\",\n  \"readOnly\",\n  \"writeOnly\",\n]);\nconst EXAMPLE_HANDLED_KEYWORDS = new Set([\n  \"type\",\n  \"enum\",\n  \"const\",\n  \"properties\",\n  \"required\",\n  \"additionalProperties\",\n  \"items\",\n  \"minItems\",\n  \"maxItems\",\n  \"minLength\",\n  \"maxLength\",\n  \"minimum\",\n  \"maximum\",\n  \"exclusiveMinimum\",\n  \"exclusiveMaximum\",\n  \"anyOf\",\n  \"oneOf\",\n]);\n\n/**\n * inputSchema 를 만족하는 예시 인스턴스 생성. 지원 keyword 집합 밖의 제약\n * (pattern/format/$ref/allOf/not/if/multipleOf/uniqueItems/...)을 만나면 값을\n * 지어내지 않고 { ok: false } 를 돌려준다 — 계약 위반 예시는 모델이 베낀다.\n */\nfunction exampleValueForSchema(schema: unknown): ExampleResult {\n  if (schema === true || schema === undefined) return { ok: true, value: {} };\n  if (schema === null || typeof schema !== \"object\" || Array.isArray(schema)) return { ok: false };\n  const node = schema as Record<string, unknown>;\n\n  for (const keyword of Object.keys(node)) {\n    if (!EXAMPLE_HANDLED_KEYWORDS.has(keyword) && !EXAMPLE_ANNOTATION_KEYWORDS.has(keyword)) {\n      return { ok: false };\n    }\n  }\n\n  if (Array.isArray(node.enum) && node.enum.length > 0) return { ok: true, value: node.enum[0] };\n  if (\"const\" in node) return { ok: true, value: node.const };\n\n  for (const kw of [\"anyOf\", \"oneOf\"] as const) {\n    if (Array.isArray(node[kw])) {\n      // oneOf 는 \"정확히 하나\"라 첫 브랜치 값이 다른 브랜치에도 매칭될 수 있다 —\n      // 검증기 없이 확신할 수 없으므로 브랜치가 하나일 때만 생성한다.\n      const list = node[kw] as unknown[];\n      if (kw === \"oneOf\" && list.length > 1) return { ok: false };\n      for (const branch of list) {\n        const result = exampleValueForSchema(branch);\n        if (result.ok) return result;\n      }\n      return { ok: false };\n    }\n  }\n\n  const type = Array.isArray(node.type) ? node.type[0] : node.type;\n  switch (type) {\n    case \"string\": {\n      const min = typeof node.minLength === \"number\" ? node.minLength : 0;\n      if (min > 64) return { ok: false };\n      const base = \"example\";\n      const value = base.length >= min ? base : base.padEnd(min, \"x\");\n      if (typeof node.maxLength === \"number\" && value.length > node.maxLength) {\n        if (node.maxLength < min) return { ok: false };\n        return { ok: true, value: value.slice(0, node.maxLength) };\n      }\n      return { ok: true, value };\n    }\n    case \"number\":\n    case \"integer\": {\n      let value = 0;\n      if (typeof node.minimum === \"number\") value = node.minimum;\n      else if (typeof node.exclusiveMinimum === \"number\") value = node.exclusiveMinimum + 1;\n      if (typeof node.maximum === \"number\" && value > node.maximum) return { ok: false };\n      if (typeof node.exclusiveMaximum === \"number\" && value >= node.exclusiveMaximum) {\n        return { ok: false };\n      }\n      return { ok: true, value };\n    }\n    case \"boolean\":\n      return { ok: true, value: false };\n    case \"null\":\n      return { ok: true, value: null };\n    case \"array\": {\n      const min = typeof node.minItems === \"number\" ? node.minItems : 0;\n      if (min > 8) return { ok: false };\n      if (typeof node.maxItems === \"number\" && node.maxItems < min) return { ok: false };\n      if (min === 0) return { ok: true, value: [] };\n      const item = exampleValueForSchema(node.items);\n      if (!item.ok) return { ok: false };\n      // 같은 값 반복이라 uniqueItems 와 충돌하지만, uniqueItems 는 지원 집합 밖이라\n      // 위의 keyword 검사에서 이미 fail-closed 된다.\n      return { ok: true, value: Array.from({ length: min }, () => item.value) };\n    }\n    case undefined:\n    case \"object\": {\n      const properties =\n        node.properties && typeof node.properties === \"object\" && !Array.isArray(node.properties)\n          ? (node.properties as Record<string, unknown>)\n          : {};\n      const required = Array.isArray(node.required)\n        ? node.required.filter((k): k is string => typeof k === \"string\")\n        : [];\n      const entries: Array<[string, unknown]> = [];\n      for (const key of required) {\n        const child = exampleValueForSchema(properties[key]);\n        if (!child.ok) return { ok: false };\n        entries.push([key, child.value]);\n      }\n      return { ok: true, value: Object.fromEntries(entries) };\n    }\n    default:\n      return { ok: false };\n  }\n}\n\n// envelope 계약 문구는 buildToolCallSchema 의 description 들과 같은 표현을 쓴다\n// (\"Do not invoke ... as native Claude Code tools\" 등) — 모델이 structured/프롬프트\n// 어느 안내를 받아도 같은 규칙을 읽게 한다.\nexport function renderToolEnvelopePrompt(tools: QgridTool[], jsonSchema?: string): string {\n  const { toolCallExample, textAnswerExample } = buildEnvelopeExamples(tools);\n\n  const toolList = tools\n    .map((tool) => {\n      const description = tool.description ? ` — ${tool.description}` : \"\";\n      return `- ${tool.name}${description}\\n  inputSchema: ${JSON.stringify(tool.inputSchema)}`;\n    })\n    .join(\"\\n\");\n\n  // 예시가 raw-JSON-only 규칙을 스스로 어기면 안 된다: json answer 는 스키마 종속이라\n  // 유효한 리터럴 예시를 만들 수 없으므로 예시 없이 프로즈로만 서술한다 (자리표시자가\n  // 섞인 비 JSON 예시를 모델이 그대로 베끼는 것 방지).\n  const answerVariant =\n    jsonSchema === undefined\n      ? [\n          \"2. Final answer — use only when no further client tool result is needed:\",\n          textAnswerExample,\n          '- \"toolCalls\" must be null.',\n          '- \"answer\" must be a plain string with your final answer (not null).',\n        ]\n      : [\n          \"2. Final answer — use only when no further client tool result is needed:\",\n          '- Set \"action\" to \"answer\" and \"toolCalls\" to null.',\n          '- \"answer\" must be a JSON value (not null, and not a string of JSON) that conforms to the JSON Schema below.',\n          \"\",\n          \"<answer-json-schema>\",\n          jsonSchema,\n          \"</answer-json-schema>\",\n        ];\n\n  // 예시 생성기가 다루지 못하는 inputSchema(fail-closed)면 구조 서술로 대체한다 —\n  // 스키마를 위반할 수 있는 예시를 싣는 것보다 예시가 없는 편이 안전하다.\n  const toolCallVariant = [\n    toolCallExample !== undefined\n      ? \"1. Request client-side tool execution, for example:\"\n      : \"1. Request client-side tool execution:\",\n    ...(toolCallExample !== undefined\n      ? [toolCallExample]\n      : [\n          '- Set \"action\" to \"tool_call\" and \"answer\" to null.',\n          '- \"toolCalls\" is an array of objects, each {\"toolName\": ..., \"args\": ...}.',\n        ]),\n    '- \"toolCalls\" must contain at least one entry.',\n    '- \"toolName\" must be one of the client tool names listed below.',\n    '- \"args\" must be the tool arguments encoded as a JSON string (not an object), conforming to that tool\\'s inputSchema.',\n    '- \"answer\" must be null.',\n  ];\n\n  return [\n    \"## Client Tool Protocol\",\n    \"\",\n    \"The client-side tools listed below are executed by the client, which returns each result\",\n    \"in a follow-up turn. Do not invoke them as native Claude Code tools.\",\n    \"\",\n    'Your entire reply must be a single JSON object of the form {\"result\": ...} —',\n    \"raw JSON only, no code fences, no prose before or after the JSON.\",\n    'The \"result\" value is exactly one of the two variants:',\n    \"\",\n    ...toolCallVariant,\n    \"\",\n    ...answerVariant,\n    \"\",\n    \"Available client tools:\",\n    toolList,\n  ].join(\"\\n\");\n}\n"],"mappings":"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"}

package/bundle/dist/application/qgrid/tool-emulation.js

@@ -44,8 +44,9 @@ function parseEnvelope(text, tools, answerKind) {
 	try {
 		value = JSON.parse(text);
 	} catch (error) {
-		logger.warn(`tool envelope parse failed: ${error.message}`);
-		throw new ToolCallEmulationError(`invalid tool envelope: ${error.message}`);
+		const head = JSON.stringify(text.slice(0, 200));
+		logger.warn(`tool envelope parse failed: ${error.message}; head=${head}`);
+		throw new ToolCallEmulationError(`invalid tool envelope (response is not JSON — the model ignored the envelope contract; retry is the caller's decision): ${error.message}; response head: ${head}`);
 	}
 	assertStructuredEnvelopeComplexity(value);
 	const validation = (answerKind === "text" ? TEXT_ENVELOPE : JSON_ENVELOPE).safeParse(value);
@@ -53,8 +54,9 @@ function parseEnvelope(text, tools, answerKind) {
 		const issue = validation.error.issues[0];
 		const path = issue && issue.path.length > 0 ? ` at ${issue.path.join(".")}` : "";
 		const detail = issue?.message ?? "unknown validation issue";
-		logger.warn(`tool envelope validation failed${path}: ${detail}`);
-		throw new ToolCallEmulationError(`invalid tool envelope${path}: ${detail}`);
+		const head = JSON.stringify(text.slice(0, 200));
+		logger.warn(`tool envelope validation failed${path}: ${detail}; head=${head}`);
+		throw new ToolCallEmulationError(`invalid tool envelope${path}: ${detail}; response head: ${head}`);
 	}
 	const response = value.result;
 	if (response.action === "tool_call") {
@@ -123,4 +125,4 @@ function assertStructuredEnvelopeComplexity(root) {
 //#endregion
 export { ToolCallEmulationError, applyToolCallEmulation };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"tool-emulation.js","names":[],"sources":["../../../src/application/qgrid/tool-emulation.ts"],"sourcesContent":["import { Buffer } from \"node:buffer\";\n\nimport { getLogger } from \"@logtape/logtape\";\nimport { z } from \"zod\";\n\n// 응답(모델 출력) envelope 의 자원 한도. caller 스키마 전처리 한도(CALLER_SCHEMA_LIMITS)와 값이\n// 같아 보여도 서로 다른 자원을 지키는 독립 상수다 — 스키마 깊이는 인스턴스 깊이를 bound 하지\n// 않으므로(재귀 $ref 허용) 캘러 한도를 조정해도 응답 수용 기준이 따라 움직여선 안 된다.\nconst STRUCTURED_ENVELOPE_LIMITS = {\n  maxUtf8Bytes: 512 * 1024,\n  maxNodes: 20_000,\n  maxDepth: 132,\n} as const;\nimport {\n  type QgridContent,\n  type QgridThreadCoord,\n  type QgridTool,\n  type QueryOutput,\n} from \"./qgrid.types\";\n\nconst logger = getLogger([\"qgrid\", \"tool-emulation\"]);\n\ntype EmulationResult = Omit<QueryOutput, \"content\" | \"finishReason\" | \"runContext\">;\ntype ToolCall = { toolName: string; args: string };\n\n// envelope 는 {result: <union>} 한 겹 구조 — 스키마 근거는 tool-emulation-schema.ts 참조.\n// answer 타입만 요청 형태에 따라 다르다: tools-only 는 string(그대로 반환),\n// tools+jsonSchema 는 사용자 스키마의 JSON 값(JSON.stringify 로 반환).\nfunction buildEnvelopeSchema(answerKind: AnswerKind) {\n  return z.strictObject({\n    result: z.discriminatedUnion(\"action\", [\n      z.strictObject({\n        action: z.literal(\"answer\"),\n        answer:\n          answerKind === \"text\"\n            ? z.string()\n            : z.json().refine((answer) => answer !== null, {\n                message: \"answer must be non-null\",\n              }),\n        toolCalls: z.null(),\n      }),\n      z.strictObject({\n        action: z.literal(\"tool_call\"),\n        answer: z.null(),\n        toolCalls: z\n          .array(\n            z.strictObject({\n              toolName: z.string(),\n              args: z.string(),\n            }),\n          )\n          .min(1),\n      }),\n    ]),\n  });\n}\n\nconst TEXT_ENVELOPE = buildEnvelopeSchema(\"text\");\nconst JSON_ENVELOPE = buildEnvelopeSchema(\"json\");\ntype EnvelopeResponse = z.infer<typeof JSON_ENVELOPE>[\"result\"];\n\nexport class ToolCallEmulationError extends Error {\n  constructor(message: string) {\n    super(`tool-call emulation: ${message}`);\n    this.name = \"ToolCallEmulationError\";\n  }\n}\n\n// dispatcher 가 넘기는 이미지 결과. qgrid 는 base64 payload 만 전달하고 포맷은 보장하지 않는다.\ninterface EmulationImage {\n  data: string;\n  revisedPrompt?: string | null;\n}\n\n// answer 인코딩 종류. envelope 디코더는 한 벌이고 이 값은 answer 브랜치의 타입과\n// 최종 직렬화(text: 그대로 / json: JSON.stringify)만 가른다.\nexport type AnswerKind = \"text\" | \"json\";\n\ninterface ToolCallEmulationOptions {\n  threadCoord?: QgridThreadCoord;\n  images?: EmulationImage[];\n  // 필수: 호출부가 answer 인코딩을 항상 명시해야 한다 (input.jsonSchema 유무로 판정).\n  answerKind: AnswerKind;\n}\n\nexport function applyToolCallEmulation(\n  result: EmulationResult,\n  tools: QgridTool[] | undefined,\n  options: ToolCallEmulationOptions,\n): QueryOutput {\n  const { threadCoord, images, answerKind } = options;\n  const runContext = threadCoord ? { threadCoord } : undefined;\n\n  if (!tools?.length) {\n    return answerOutput(result, result.text, images, runContext);\n  }\n\n  const parsed = parseEnvelope(result.text, tools, answerKind);\n  if (parsed.action === \"tool_call\") {\n    return toolCallOutput(result, parsed.toolCalls, images, runContext);\n  }\n\n  return answerOutput(\n    result,\n    answerKind === \"text\" ? (parsed.answer as string) : JSON.stringify(parsed.answer),\n    images,\n    runContext,\n  );\n}\n\nfunction parseEnvelope(text: string, tools: QgridTool[], answerKind: AnswerKind) {\n  if (Buffer.byteLength(text, \"utf8\") > STRUCTURED_ENVELOPE_LIMITS.maxUtf8Bytes) {\n    throw new ToolCallEmulationError(\n      `tool envelope exceeds UTF-8 byte limit of ${STRUCTURED_ENVELOPE_LIMITS.maxUtf8Bytes}`,\n    );\n  }\n\n  let value: unknown;\n  try {\n    value = JSON.parse(text);\n  } catch (error) {\n    // 관용 폴백 없음: envelope 는 양 provider 의 structured output 으로 강제되는 내부\n    // 계약이라 여기 도달한 비 JSON 은 버그다. 과거의 텍스트 구제는 퇴화 봉투를 답변으로\n    // 흘려보내 조용한 오염을 만들었다(2026-07 medpath, 13.5k 건).\n    logger.warn(`tool envelope parse failed: ${(error as Error).message}`);\n    throw new ToolCallEmulationError(`invalid tool envelope: ${(error as Error).message}`);\n  }\n\n  assertStructuredEnvelopeComplexity(value);\n  const schema = answerKind === \"text\" ? TEXT_ENVELOPE : JSON_ENVELOPE;\n  const validation = schema.safeParse(value);\n  if (!validation.success) {\n    const issue = validation.error.issues[0];\n    const path = issue && issue.path.length > 0 ? ` at ${issue.path.join(\".\")}` : \"\";\n    const detail = issue?.message ?? \"unknown validation issue\";\n    logger.warn(`tool envelope validation failed${path}: ${detail}`);\n    throw new ToolCallEmulationError(`invalid tool envelope${path}: ${detail}`);\n  }\n\n  // Zod clones JSON objects and drops own \"__proto__\" keys. The parsed JSON is safe to return\n  // after validation and preserves the caller's exact structured value.\n  const response = (value as { result: EnvelopeResponse }).result;\n  if (response.action === \"tool_call\") {\n    const unknownTool = findUnknownTool(response.toolCalls, tools);\n    if (unknownTool !== undefined) {\n      throw new ToolCallEmulationError(`unknown emulated tool: ${unknownTool}`);\n    }\n  }\n  return response;\n}\n\nfunction toolCallOutput(\n  result: EmulationResult,\n  toolCalls: ToolCall[],\n  images: EmulationImage[] | undefined,\n  runContext: QueryOutput[\"runContext\"],\n): QueryOutput {\n  return {\n    ...result,\n    content: appendImages(\n      toolCalls.map((toolCall) => ({\n        type: \"tool-call\",\n        toolCallId: `call_${Math.random().toString(36).slice(2, 10)}`,\n        toolName: toolCall.toolName,\n        input: toolCall.args,\n      })),\n      images,\n    ),\n    finishReason: \"tool-calls\",\n    runContext,\n  };\n}\n\nfunction answerOutput(\n  result: EmulationResult,\n  text: string,\n  images: EmulationImage[] | undefined,\n  runContext: QueryOutput[\"runContext\"],\n): QueryOutput {\n  return {\n    ...result,\n    text,\n    content: appendImages([{ type: \"text\", text }], images),\n    finishReason: \"stop\",\n    runContext,\n  };\n}\n\nfunction findUnknownTool(toolCalls: ToolCall[], tools: QgridTool[]): string | undefined {\n  const knownToolNames = new Set(tools.map((tool) => tool.name));\n  return toolCalls.find((toolCall) => !knownToolNames.has(toolCall.toolName))?.toolName;\n}\n\nfunction appendImages(content: QgridContent[], images?: EmulationImage[]): QgridContent[] {\n  if (!images?.length) return content;\n  return [\n    ...content,\n    ...images.map(\n      (image): QgridContent => ({\n        type: \"image\",\n        data: image.data,\n        revisedPrompt: image.revisedPrompt ?? null,\n      }),\n    ),\n  ];\n}\n\nfunction assertStructuredEnvelopeComplexity(root: unknown): void {\n  const maxDepth = STRUCTURED_ENVELOPE_LIMITS.maxDepth;\n  const stack = [{ value: root, depth: 0 }];\n  let nodes = 0;\n\n  while (stack.length > 0) {\n    const current = stack.pop()!;\n    nodes += 1;\n    if (nodes > STRUCTURED_ENVELOPE_LIMITS.maxNodes) {\n      throw new ToolCallEmulationError(\n        `structured-output envelope exceeds node limit of ${STRUCTURED_ENVELOPE_LIMITS.maxNodes}`,\n      );\n    }\n    if (current.depth > maxDepth) {\n      throw new ToolCallEmulationError(\n        `structured-output envelope exceeds depth limit of ${maxDepth}`,\n      );\n    }\n    if (typeof current.value === \"number\" && !Number.isFinite(current.value)) {\n      throw new ToolCallEmulationError(\"answer must be valid JSON\");\n    }\n    if (current.value === null || typeof current.value !== \"object\") continue;\n\n    for (const value of Object.values(current.value)) {\n      stack.push({ value, depth: current.depth + 1 });\n    }\n  }\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"tool-emulation.js","names":[],"sources":["../../../src/application/qgrid/tool-emulation.ts"],"sourcesContent":["import { Buffer } from \"node:buffer\";\n\nimport { getLogger } from \"@logtape/logtape\";\nimport { z } from \"zod\";\n\n// 응답(모델 출력) envelope 의 자원 한도. caller 스키마 전처리 한도(CALLER_SCHEMA_LIMITS)와 값이\n// 같아 보여도 서로 다른 자원을 지키는 독립 상수다 — 스키마 깊이는 인스턴스 깊이를 bound 하지\n// 않으므로(재귀 $ref 허용) 캘러 한도를 조정해도 응답 수용 기준이 따라 움직여선 안 된다.\nconst STRUCTURED_ENVELOPE_LIMITS = {\n  maxUtf8Bytes: 512 * 1024,\n  maxNodes: 20_000,\n  maxDepth: 132,\n} as const;\nimport {\n  type QgridContent,\n  type QgridThreadCoord,\n  type QgridTool,\n  type QueryOutput,\n} from \"./qgrid.types\";\n\nconst logger = getLogger([\"qgrid\", \"tool-emulation\"]);\n\ntype EmulationResult = Omit<QueryOutput, \"content\" | \"finishReason\" | \"runContext\">;\ntype ToolCall = { toolName: string; args: string };\n\n// envelope 는 {result: <union>} 한 겹 구조 — 스키마 근거는 tool-emulation-schema.ts 참조.\n// answer 타입만 요청 형태에 따라 다르다: tools-only 는 string(그대로 반환),\n// tools+jsonSchema 는 사용자 스키마의 JSON 값(JSON.stringify 로 반환).\nfunction buildEnvelopeSchema(answerKind: AnswerKind) {\n  return z.strictObject({\n    result: z.discriminatedUnion(\"action\", [\n      z.strictObject({\n        action: z.literal(\"answer\"),\n        answer:\n          answerKind === \"text\"\n            ? z.string()\n            : z.json().refine((answer) => answer !== null, {\n                message: \"answer must be non-null\",\n              }),\n        toolCalls: z.null(),\n      }),\n      z.strictObject({\n        action: z.literal(\"tool_call\"),\n        answer: z.null(),\n        toolCalls: z\n          .array(\n            z.strictObject({\n              toolName: z.string(),\n              args: z.string(),\n            }),\n          )\n          .min(1),\n      }),\n    ]),\n  });\n}\n\nconst TEXT_ENVELOPE = buildEnvelopeSchema(\"text\");\nconst JSON_ENVELOPE = buildEnvelopeSchema(\"json\");\ntype EnvelopeResponse = z.infer<typeof JSON_ENVELOPE>[\"result\"];\n\nexport class ToolCallEmulationError extends Error {\n  constructor(message: string) {\n    super(`tool-call emulation: ${message}`);\n    this.name = \"ToolCallEmulationError\";\n  }\n}\n\n// dispatcher 가 넘기는 이미지 결과. qgrid 는 base64 payload 만 전달하고 포맷은 보장하지 않는다.\ninterface EmulationImage {\n  data: string;\n  revisedPrompt?: string | null;\n}\n\n// answer 인코딩 종류. envelope 디코더는 한 벌이고 이 값은 answer 브랜치의 타입과\n// 최종 직렬화(text: 그대로 / json: JSON.stringify)만 가른다.\nexport type AnswerKind = \"text\" | \"json\";\n\ninterface ToolCallEmulationOptions {\n  threadCoord?: QgridThreadCoord;\n  images?: EmulationImage[];\n  // 필수: 호출부가 answer 인코딩을 항상 명시해야 한다 (input.jsonSchema 유무로 판정).\n  answerKind: AnswerKind;\n}\n\nexport function applyToolCallEmulation(\n  result: EmulationResult,\n  tools: QgridTool[] | undefined,\n  options: ToolCallEmulationOptions,\n): QueryOutput {\n  const { threadCoord, images, answerKind } = options;\n  const runContext = threadCoord ? { threadCoord } : undefined;\n\n  if (!tools?.length) {\n    return answerOutput(result, result.text, images, runContext);\n  }\n\n  const parsed = parseEnvelope(result.text, tools, answerKind);\n  if (parsed.action === \"tool_call\") {\n    return toolCallOutput(result, parsed.toolCalls, images, runContext);\n  }\n\n  return answerOutput(\n    result,\n    answerKind === \"text\" ? (parsed.answer as string) : JSON.stringify(parsed.answer),\n    images,\n    runContext,\n  );\n}\n\nfunction parseEnvelope(text: string, tools: QgridTool[], answerKind: AnswerKind) {\n  if (Buffer.byteLength(text, \"utf8\") > STRUCTURED_ENVELOPE_LIMITS.maxUtf8Bytes) {\n    throw new ToolCallEmulationError(\n      `tool envelope exceeds UTF-8 byte limit of ${STRUCTURED_ENVELOPE_LIMITS.maxUtf8Bytes}`,\n    );\n  }\n\n  let value: unknown;\n  try {\n    value = JSON.parse(text);\n  } catch (error) {\n    // 관용 폴백 없음. openai 는 envelope 이 structured output 으로 강제되므로 여기 도달한\n    // 비 JSON 은 버그다. anthropic 은 계약을 프롬프트로만 안내하므로(SON-532) 비 JSON 이\n    // \"예상 가능한 모델 실패\"지만, 그래도 구제하지 않는다 — 과거의 텍스트 구제는 퇴화\n    // 봉투를 답변으로 흘려보내 조용한 오염을 만들었다(2026-07 medpath, 13.5k 건).\n    // 정직한 실패가 보여야 소비자가 재시도하거나 근본 원인을 고친다.\n    // 진단에는 위반 원문의 머리가 필요하다(SON-495 전례) — parse 에러 위치만으로는\n    // \"프로즈로 답했는지 / 펜스가 남았는지 / JSON 이 잘렸는지\"를 구분할 수 없다.\n    const head = JSON.stringify(text.slice(0, 200));\n    logger.warn(`tool envelope parse failed: ${(error as Error).message}; head=${head}`);\n    throw new ToolCallEmulationError(\n      `invalid tool envelope (response is not JSON — the model ignored the envelope contract; retry is the caller's decision): ${(error as Error).message}; response head: ${head}`,\n    );\n  }\n\n  assertStructuredEnvelopeComplexity(value);\n  const schema = answerKind === \"text\" ? TEXT_ENVELOPE : JSON_ENVELOPE;\n  const validation = schema.safeParse(value);\n  if (!validation.success) {\n    const issue = validation.error.issues[0];\n    const path = issue && issue.path.length > 0 ? ` at ${issue.path.join(\".\")}` : \"\";\n    const detail = issue?.message ?? \"unknown validation issue\";\n    // valid JSON 이지만 계약 위반인 경우에도 원문 머리를 남긴다 — zod 경로만으로는\n    // \"키 생략인지 / 래퍼로 감쌌는지 / 타입이 틀렸는지\"의 실물을 볼 수 없다.\n    const head = JSON.stringify(text.slice(0, 200));\n    logger.warn(`tool envelope validation failed${path}: ${detail}; head=${head}`);\n    throw new ToolCallEmulationError(\n      `invalid tool envelope${path}: ${detail}; response head: ${head}`,\n    );\n  }\n\n  // Zod clones JSON objects and drops own \"__proto__\" keys. The parsed JSON is safe to return\n  // after validation and preserves the caller's exact structured value.\n  const response = (value as { result: EnvelopeResponse }).result;\n  if (response.action === \"tool_call\") {\n    const unknownTool = findUnknownTool(response.toolCalls, tools);\n    if (unknownTool !== undefined) {\n      throw new ToolCallEmulationError(`unknown emulated tool: ${unknownTool}`);\n    }\n  }\n  return response;\n}\n\nfunction toolCallOutput(\n  result: EmulationResult,\n  toolCalls: ToolCall[],\n  images: EmulationImage[] | undefined,\n  runContext: QueryOutput[\"runContext\"],\n): QueryOutput {\n  return {\n    ...result,\n    content: appendImages(\n      toolCalls.map((toolCall) => ({\n        type: \"tool-call\",\n        toolCallId: `call_${Math.random().toString(36).slice(2, 10)}`,\n        toolName: toolCall.toolName,\n        input: toolCall.args,\n      })),\n      images,\n    ),\n    finishReason: \"tool-calls\",\n    runContext,\n  };\n}\n\nfunction answerOutput(\n  result: EmulationResult,\n  text: string,\n  images: EmulationImage[] | undefined,\n  runContext: QueryOutput[\"runContext\"],\n): QueryOutput {\n  return {\n    ...result,\n    text,\n    content: appendImages([{ type: \"text\", text }], images),\n    finishReason: \"stop\",\n    runContext,\n  };\n}\n\nfunction findUnknownTool(toolCalls: ToolCall[], tools: QgridTool[]): string | undefined {\n  const knownToolNames = new Set(tools.map((tool) => tool.name));\n  return toolCalls.find((toolCall) => !knownToolNames.has(toolCall.toolName))?.toolName;\n}\n\nfunction appendImages(content: QgridContent[], images?: EmulationImage[]): QgridContent[] {\n  if (!images?.length) return content;\n  return [\n    ...content,\n    ...images.map(\n      (image): QgridContent => ({\n        type: \"image\",\n        data: image.data,\n        revisedPrompt: image.revisedPrompt ?? null,\n      }),\n    ),\n  ];\n}\n\nfunction assertStructuredEnvelopeComplexity(root: unknown): void {\n  const maxDepth = STRUCTURED_ENVELOPE_LIMITS.maxDepth;\n  const stack = [{ value: root, depth: 0 }];\n  let nodes = 0;\n\n  while (stack.length > 0) {\n    const current = stack.pop()!;\n    nodes += 1;\n    if (nodes > STRUCTURED_ENVELOPE_LIMITS.maxNodes) {\n      throw new ToolCallEmulationError(\n        `structured-output envelope exceeds node limit of ${STRUCTURED_ENVELOPE_LIMITS.maxNodes}`,\n      );\n    }\n    if (current.depth > maxDepth) {\n      throw new ToolCallEmulationError(\n        `structured-output envelope exceeds depth limit of ${maxDepth}`,\n      );\n    }\n    if (typeof current.value === \"number\" && !Number.isFinite(current.value)) {\n      throw new ToolCallEmulationError(\"answer must be valid JSON\");\n    }\n    if (current.value === null || typeof current.value !== \"object\") continue;\n\n    for (const value of Object.values(current.value)) {\n      stack.push({ value, depth: current.depth + 1 });\n    }\n  }\n}\n"],"mappings":"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"}

package/bundle/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/2020.js

@@ -0,0 +1,112 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.js";
+import { require_codegen } from "./compile/codegen/index.js";
+import { require_validate } from "./compile/validate/index.js";
+import { require_validation_error } from "./runtime/validation_error.js";
+import { require_ref_error } from "./compile/ref_error.js";
+import { require_core } from "./core.js";
+import { require_draft2020 } from "./vocabularies/draft2020.js";
+import { require_discriminator } from "./vocabularies/discriminator/index.js";
+import { require_json_schema_2020_12 } from "./refs/json-schema-2020-12/index.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/2020.js
+var require__2020 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.MissingRefError = exports.ValidationError = exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = exports.Ajv2020 = void 0;
+	const core_1 = require_core();
+	const draft2020_1 = require_draft2020();
+	const discriminator_1 = require_discriminator();
+	const json_schema_2020_12_1 = require_json_schema_2020_12();
+	const META_SCHEMA_ID = "https://json-schema.org/draft/2020-12/schema";
+	var Ajv2020 = class extends core_1.default {
+		constructor(opts = {}) {
+			super({
+				...opts,
+				dynamicRef: true,
+				next: true,
+				unevaluated: true
+			});
+		}
+		_addVocabularies() {
+			super._addVocabularies();
+			draft2020_1.default.forEach((v) => this.addVocabulary(v));
+			if (this.opts.discriminator) this.addKeyword(discriminator_1.default);
+		}
+		_addDefaultMetaSchema() {
+			super._addDefaultMetaSchema();
+			const { $data, meta } = this.opts;
+			if (!meta) return;
+			json_schema_2020_12_1.default.call(this, $data);
+			this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID;
+		}
+		defaultMeta() {
+			return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0);
+		}
+	};
+	exports.Ajv2020 = Ajv2020;
+	module.exports = exports = Ajv2020;
+	module.exports.Ajv2020 = Ajv2020;
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.default = Ajv2020;
+	var validate_1 = require_validate();
+	Object.defineProperty(exports, "KeywordCxt", {
+		enumerable: true,
+		get: function() {
+			return validate_1.KeywordCxt;
+		}
+	});
+	var codegen_1 = require_codegen();
+	Object.defineProperty(exports, "_", {
+		enumerable: true,
+		get: function() {
+			return codegen_1._;
+		}
+	});
+	Object.defineProperty(exports, "str", {
+		enumerable: true,
+		get: function() {
+			return codegen_1.str;
+		}
+	});
+	Object.defineProperty(exports, "stringify", {
+		enumerable: true,
+		get: function() {
+			return codegen_1.stringify;
+		}
+	});
+	Object.defineProperty(exports, "nil", {
+		enumerable: true,
+		get: function() {
+			return codegen_1.nil;
+		}
+	});
+	Object.defineProperty(exports, "Name", {
+		enumerable: true,
+		get: function() {
+			return codegen_1.Name;
+		}
+	});
+	Object.defineProperty(exports, "CodeGen", {
+		enumerable: true,
+		get: function() {
+			return codegen_1.CodeGen;
+		}
+	});
+	var validation_error_1 = require_validation_error();
+	Object.defineProperty(exports, "ValidationError", {
+		enumerable: true,
+		get: function() {
+			return validation_error_1.default;
+		}
+	});
+	var ref_error_1 = require_ref_error();
+	Object.defineProperty(exports, "MissingRefError", {
+		enumerable: true,
+		get: function() {
+			return ref_error_1.default;
+		}
+	});
+}));
+//#endregion
+export default require__2020();
+export { require__2020 };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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