@cartanova/qgrid-cli 2.10.10 → 2.11.0

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

@@ -1,5 +1,24 @@
+import { isJsonObject, jsonValueSchema } from "../../utils/providers/common/provider-types.js";
+import { z } from "zod";
 //#region src/application/qgrid/schema-prompt.ts
 /**
+* output schema / tool envelope 계약의 프롬프트 렌더링 (SON-532).
+*
+* anthropic 경로는 CC 에 --json-schema 를 전달하지 않는다 — 강제 없는 사후 채점(AJV)이
+* 소비자 의도와 충돌해 내부 재시도 루프를 만들었기 때문. 대신 여기서 계약을 텍스트로
+* 렌더해 system prompt 말미에 주입하고, 판정은 소비자 zod(스키마) / parseEnvelope
+* (envelope, tool-emulation.ts)가 맡는다.
+*
+* 원칙:
+* - user 스키마는 수신 원형 그대로 안내한다 — strictify(전 필드 required 강제,
+*   additionalProperties:false)를 거치지 않아 소비자의 nullish/optional 의도가 보존된다.
+* - envelope 은 buildToolCallSchema(tool-emulation-schema.ts)처럼 user 스키마를 $defs 로
+*   합성하지 않는다. 텍스트 안내라 `$ref` 문서 루트 충돌이 없어 rebase 가 불필요하고,
+*   그 덕에 rebase 가 거절하던 형태(named anchor $ref 등)도 그대로 통과한다.
+* - 렌더된 계약은 parseEnvelope 의 zod 계약({"result": ...} 한 겹, 상호배타 변형)과
+*   정확히 일치해야 한다 — 교차 테스트(schema-prompt.test.ts)가 드리프트를 막는다.
+*/
+/**
 * system prompt 말미에 계약을 덧붙인다. anthropic 은 cold-only(매 턴 CC 재스폰 + system
 * 재전송)라 멀티턴에도 계약이 매 턴 일관되게 주입된다. system 이 argv 64KB 를 넘으면
 * claude-session 의 --system-prompt-file 분기가 흡수한다.
@@ -27,36 +46,35 @@ function renderOutputSchemaPrompt(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) : {
+	const args = exampleArgsForTool(firstTool);
+	const examples = { textAnswerExample: JSON.stringify({ result: {
+		action: "answer",
+		answer: "your final answer",
+		toolCalls: null
+	} }) };
+	if (args.ok) examples.toolCallExample = JSON.stringify({ result: {
+		action: "tool_call",
+		answer: null,
+		toolCalls: [{
+			toolName: firstTool?.name ?? "toolName",
+			args: JSON.stringify(args.value)
+		}]
+	} });
+	return examples;
+}
+/** A missing tool or schema allows any object; a schema that is not JSON yields no example. */
+function exampleArgsForTool(tool) {
+	if (tool === void 0 || tool.inputSchema === void 0) return {
 		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
-		} })
-	};
+	const inputSchema = jsonValueSchema.safeParse(tool.inputSchema);
+	return inputSchema.success ? exampleValueForSchema(inputSchema.data) : { ok: false };
+}
+function jsonNumber(value) {
+	return z.number().safeParse(value).data;
 }
 /** 생성기가 값 선택에 반영하는 keyword. 어노테이션(description 등)은 값과 무관해 무시한다. */
 const EXAMPLE_ANNOTATION_KEYWORDS = /* @__PURE__ */ new Set([
@@ -98,37 +116,41 @@ function exampleValueForSchema(schema) {
 		ok: true,
 		value: {}
 	};
-	if (schema === null || typeof schema !== "object" || Array.isArray(schema)) return { ok: false };
+	if (!isJsonObject(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 {
+	const enumValues = node.enum;
+	if (Array.isArray(enumValues) && enumValues.length > 0) return {
 		ok: true,
-		value: node.enum[0]
+		value: enumValues[0] ?? null
 	};
 	if ("const" in node) return {
 		ok: true,
-		value: node.const
+		value: node.const ?? null
 	};
-	for (const kw of ["anyOf", "oneOf"]) if (Array.isArray(node[kw])) {
+	for (const kw of ["anyOf", "oneOf"]) {
 		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;
+		if (Array.isArray(list)) {
+			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 };
 		}
-		return { ok: false };
 	}
 	switch (Array.isArray(node.type) ? node.type[0] : node.type) {
 		case "string": {
-			const min = typeof node.minLength === "number" ? node.minLength : 0;
+			const min = jsonNumber(node.minLength) ?? 0;
+			const maxLength = jsonNumber(node.maxLength);
 			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 };
+			if (maxLength !== void 0 && value.length > maxLength) {
+				if (maxLength < min) return { ok: false };
 				return {
 					ok: true,
-					value: value.slice(0, node.maxLength)
+					value: value.slice(0, maxLength)
 				};
 			}
 			return {
@@ -139,10 +161,14 @@ function exampleValueForSchema(schema) {
 		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 };
+			const minimum = jsonNumber(node.minimum);
+			const exclusiveMinimum = jsonNumber(node.exclusiveMinimum);
+			const maximum = jsonNumber(node.maximum);
+			const exclusiveMaximum = jsonNumber(node.exclusiveMaximum);
+			if (minimum !== void 0) value = minimum;
+			else if (exclusiveMinimum !== void 0) value = exclusiveMinimum + 1;
+			if (maximum !== void 0 && value > maximum) return { ok: false };
+			if (exclusiveMaximum !== void 0 && value >= exclusiveMaximum) return { ok: false };
 			return {
 				ok: true,
 				value
@@ -157,9 +183,10 @@ function exampleValueForSchema(schema) {
 			value: null
 		};
 		case "array": {
-			const min = typeof node.minItems === "number" ? node.minItems : 0;
+			const min = jsonNumber(node.minItems) ?? 0;
+			const maxItems = jsonNumber(node.maxItems);
 			if (min > 8) return { ok: false };
-			if (typeof node.maxItems === "number" && node.maxItems < min) return { ok: false };
+			if (maxItems !== void 0 && maxItems < min) return { ok: false };
 			if (min === 0) return {
 				ok: true,
 				value: []
@@ -173,8 +200,8 @@ function exampleValueForSchema(schema) {
 		}
 		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 properties = isJsonObject(node.properties) ? node.properties : {};
+			const required = Array.isArray(node.required) ? node.required.flatMap((key) => z.string().safeParse(key).data ?? []) : [];
 			const entries = [];
 			for (const key of required) {
 				const child = exampleValueForSchema(properties[key]);
@@ -237,4 +264,4 @@ function renderToolEnvelopePrompt(tools, jsonSchema) {
 //#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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"}
+//# 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 { z } from \"zod\";\n\nimport {\n  isJsonObject,\n  type JsonObject,\n  type JsonValue,\n  jsonValueSchema,\n} from \"../../utils/providers/common/provider-types\";\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\n  if (contract === undefined) return system;\n\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\n  if (input.jsonSchema !== undefined) {\n    return renderOutputSchemaPrompt(input.jsonSchema);\n  }\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 interface EnvelopeExamples {\n  toolCallExample?: string;\n  textAnswerExample: string;\n}\n\nexport function buildEnvelopeExamples(tools: QgridTool[]): EnvelopeExamples {\n  const firstTool = tools[0];\n  const args = exampleArgsForTool(firstTool);\n\n  const examples: EnvelopeExamples = {\n    textAnswerExample: JSON.stringify({\n      result: { action: \"answer\", answer: \"your final answer\", toolCalls: null },\n    }),\n  };\n\n  if (args.ok) {\n    examples.toolCallExample = JSON.stringify({\n      result: {\n        action: \"tool_call\",\n        answer: null,\n        toolCalls: [{ toolName: firstTool?.name ?? \"toolName\", args: JSON.stringify(args.value) }],\n      },\n    });\n  }\n\n  return examples;\n}\n\ntype ExampleResult = { ok: true; value: JsonValue } | { ok: false };\n\n/** A missing tool or schema allows any object; a schema that is not JSON yields no example. */\nfunction exampleArgsForTool(tool: QgridTool | undefined): ExampleResult {\n  if (tool === undefined || tool.inputSchema === undefined) return { ok: true, value: {} };\n  const inputSchema = jsonValueSchema.safeParse(tool.inputSchema);\n\n  return inputSchema.success ? exampleValueForSchema(inputSchema.data) : { ok: false };\n}\n\nfunction jsonNumber(value: JsonValue | undefined): number | undefined {\n  return z.number().safeParse(value).data;\n}\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]);\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: JsonValue | undefined): ExampleResult {\n  if (schema === true || schema === undefined) return { ok: true, value: {} };\n\n  if (!isJsonObject(schema)) return { ok: false };\n  const node = schema;\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  const enumValues = node.enum;\n\n  if (Array.isArray(enumValues) && enumValues.length > 0) {\n    return { ok: true, value: enumValues[0] ?? null };\n  }\n\n  if (\"const\" in node) return { ok: true, value: node.const ?? null };\n\n  for (const kw of [\"anyOf\", \"oneOf\"] as const) {\n    const list = node[kw];\n\n    if (Array.isArray(list)) {\n      // oneOf 는 \"정확히 하나\"라 첫 브랜치 값이 다른 브랜치에도 매칭될 수 있다 —\n      // 검증기 없이 확신할 수 없으므로 브랜치가 하나일 때만 생성한다.\n      if (kw === \"oneOf\" && list.length > 1) return { ok: false };\n\n      for (const branch of list) {\n        const result = exampleValueForSchema(branch);\n\n        if (result.ok) return result;\n      }\n\n      return { ok: false };\n    }\n  }\n\n  const type = Array.isArray(node.type) ? node.type[0] : node.type;\n\n  switch (type) {\n    case \"string\": {\n      const min = jsonNumber(node.minLength) ?? 0;\n      const maxLength = jsonNumber(node.maxLength);\n\n      if (min > 64) return { ok: false };\n      const base = \"example\";\n      const value = base.length >= min ? base : base.padEnd(min, \"x\");\n\n      if (maxLength !== undefined && value.length > maxLength) {\n        if (maxLength < min) return { ok: false };\n\n        return { ok: true, value: value.slice(0, maxLength) };\n      }\n\n      return { ok: true, value };\n    }\n\n    case \"number\":\n    case \"integer\": {\n      let value = 0;\n      const minimum = jsonNumber(node.minimum);\n      const exclusiveMinimum = jsonNumber(node.exclusiveMinimum);\n      const maximum = jsonNumber(node.maximum);\n      const exclusiveMaximum = jsonNumber(node.exclusiveMaximum);\n\n      if (minimum !== undefined) value = minimum;\n      else if (exclusiveMinimum !== undefined) value = exclusiveMinimum + 1;\n\n      if (maximum !== undefined && value > maximum) return { ok: false };\n\n      if (exclusiveMaximum !== undefined && value >= exclusiveMaximum) {\n        return { ok: false };\n      }\n\n      return { ok: true, value };\n    }\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 = jsonNumber(node.minItems) ?? 0;\n      const maxItems = jsonNumber(node.maxItems);\n\n      if (min > 8) return { ok: false };\n\n      if (maxItems !== undefined && maxItems < min) return { ok: false };\n\n      if (min === 0) return { ok: true, value: [] };\n      const item = exampleValueForSchema(node.items);\n\n      if (!item.ok) return { ok: false };\n\n      // 같은 값 반복이라 uniqueItems 와 충돌하지만, uniqueItems 는 지원 집합 밖이라\n      // 위의 keyword 검사에서 이미 fail-closed 된다.\n      return { ok: true, value: Array.from({ length: min }, () => item.value) };\n    }\n\n    case undefined:\n    case \"object\": {\n      const properties: JsonObject = isJsonObject(node.properties) ? node.properties : {};\n\n      const required = Array.isArray(node.required)\n        ? node.required.flatMap((key) => z.string().safeParse(key).data ?? [])\n        : [];\n\n      const entries: Array<[string, JsonValue]> = [];\n\n      for (const key of required) {\n        const child = exampleValueForSchema(properties[key]);\n\n        if (!child.ok) return { ok: false };\n        entries.push([key, child.value]);\n      }\n\n      return { ok: true, value: Object.fromEntries(entries) };\n    }\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\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":";;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,SAAgB,gCACd,QACA,OACoB;CACpB,MAAM,WAAW,2BAA2B,KAAK;CAEjD,IAAI,aAAa,QAAW,OAAO;CAEnC,OAAO,SAAS,GAAG,OAAO,MAAM,aAAa;AAC/C;;AAGA,SAAgB,2BACd,OACoB;CACpB,IAAI,MAAM,OAAO,QACf,OAAO,yBAAyB,MAAM,OAAO,MAAM,UAAU;CAG/D,IAAI,MAAM,eAAe,QACvB,OAAO,yBAAyB,MAAM,UAAU;AAIpD;AAGA,SAAgB,yBAAyB,YAA4B;CACnE,OAAO;EACL;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;CACF,CAAC,CAAC,KAAK,IAAI;AACb;AAgBA,SAAgB,sBAAsB,OAAsC;CAC1E,MAAM,YAAY,MAAM;CACxB,MAAM,OAAO,mBAAmB,SAAS;CAEzC,MAAM,WAA6B,EACjC,mBAAmB,KAAK,UAAU,EAChC,QAAQ;EAAE,QAAQ;EAAU,QAAQ;EAAqB,WAAW;CAAK,EAC3E,CAAC,EACH;CAEA,IAAI,KAAK,IACP,SAAS,kBAAkB,KAAK,UAAU,EACxC,QAAQ;EACN,QAAQ;EACR,QAAQ;EACR,WAAW,CAAC;GAAE,UAAU,WAAW,QAAQ;GAAY,MAAM,KAAK,UAAU,KAAK,KAAK;EAAE,CAAC;CAC3F,EACF,CAAC;CAGH,OAAO;AACT;;AAKA,SAAS,mBAAmB,MAA4C;CACtE,IAAI,SAAS,UAAa,KAAK,gBAAgB,QAAW,OAAO;EAAE,IAAI;EAAM,OAAO,CAAC;CAAE;CACvF,MAAM,cAAc,gBAAgB,UAAU,KAAK,WAAW;CAE9D,OAAO,YAAY,UAAU,sBAAsB,YAAY,IAAI,IAAI,EAAE,IAAI,MAAM;AACrF;AAEA,SAAS,WAAW,OAAkD;CACpE,OAAO,EAAE,OAAO,CAAC,CAAC,UAAU,KAAK,CAAC,CAAC;AACrC;;AAGA,MAAM,8CAA8B,IAAI,IAAI;CAC1C;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;AAED,MAAM,2CAA2B,IAAI,IAAI;CACvC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;;;;;;AAOD,SAAS,sBAAsB,QAA8C;CAC3E,IAAI,WAAW,QAAQ,WAAW,QAAW,OAAO;EAAE,IAAI;EAAM,OAAO,CAAC;CAAE;CAE1E,IAAI,CAAC,aAAa,MAAM,GAAG,OAAO,EAAE,IAAI,MAAM;CAC9C,MAAM,OAAO;CAEb,KAAK,MAAM,WAAW,OAAO,KAAK,IAAI,GACpC,IAAI,CAAC,yBAAyB,IAAI,OAAO,KAAK,CAAC,4BAA4B,IAAI,OAAO,GACpF,OAAO,EAAE,IAAI,MAAM;CAIvB,MAAM,aAAa,KAAK;CAExB,IAAI,MAAM,QAAQ,UAAU,KAAK,WAAW,SAAS,GACnD,OAAO;EAAE,IAAI;EAAM,OAAO,WAAW,MAAM;CAAK;CAGlD,IAAI,WAAW,MAAM,OAAO;EAAE,IAAI;EAAM,OAAO,KAAK,SAAS;CAAK;CAElE,KAAK,MAAM,MAAM,CAAC,SAAS,OAAO,GAAY;EAC5C,MAAM,OAAO,KAAK;EAElB,IAAI,MAAM,QAAQ,IAAI,GAAG;GAGvB,IAAI,OAAO,WAAW,KAAK,SAAS,GAAG,OAAO,EAAE,IAAI,MAAM;GAE1D,KAAK,MAAM,UAAU,MAAM;IACzB,MAAM,SAAS,sBAAsB,MAAM;IAE3C,IAAI,OAAO,IAAI,OAAO;GACxB;GAEA,OAAO,EAAE,IAAI,MAAM;EACrB;CACF;CAIA,QAFa,MAAM,QAAQ,KAAK,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,MAE5D;EACE,KAAK,UAAU;GACb,MAAM,MAAM,WAAW,KAAK,SAAS,KAAK;GAC1C,MAAM,YAAY,WAAW,KAAK,SAAS;GAE3C,IAAI,MAAM,IAAI,OAAO,EAAE,IAAI,MAAM;GACjC,MAAM,OAAO;GACb,MAAM,QAAQ,KAAe,MAAM,OAAO,KAAK,OAAO,KAAK,GAAG;GAE9D,IAAI,cAAc,UAAa,MAAM,SAAS,WAAW;IACvD,IAAI,YAAY,KAAK,OAAO,EAAE,IAAI,MAAM;IAExC,OAAO;KAAE,IAAI;KAAM,OAAO,MAAM,MAAM,GAAG,SAAS;IAAE;GACtD;GAEA,OAAO;IAAE,IAAI;IAAM;GAAM;EAC3B;EAEA,KAAK;EACL,KAAK,WAAW;GACd,IAAI,QAAQ;GACZ,MAAM,UAAU,WAAW,KAAK,OAAO;GACvC,MAAM,mBAAmB,WAAW,KAAK,gBAAgB;GACzD,MAAM,UAAU,WAAW,KAAK,OAAO;GACvC,MAAM,mBAAmB,WAAW,KAAK,gBAAgB;GAEzD,IAAI,YAAY,QAAW,QAAQ;QAC9B,IAAI,qBAAqB,QAAW,QAAQ,mBAAmB;GAEpE,IAAI,YAAY,UAAa,QAAQ,SAAS,OAAO,EAAE,IAAI,MAAM;GAEjE,IAAI,qBAAqB,UAAa,SAAS,kBAC7C,OAAO,EAAE,IAAI,MAAM;GAGrB,OAAO;IAAE,IAAI;IAAM;GAAM;EAC3B;EAEA,KAAK,WACH,OAAO;GAAE,IAAI;GAAM,OAAO;EAAM;EAClC,KAAK,QACH,OAAO;GAAE,IAAI;GAAM,OAAO;EAAK;EACjC,KAAK,SAAS;GACZ,MAAM,MAAM,WAAW,KAAK,QAAQ,KAAK;GACzC,MAAM,WAAW,WAAW,KAAK,QAAQ;GAEzC,IAAI,MAAM,GAAG,OAAO,EAAE,IAAI,MAAM;GAEhC,IAAI,aAAa,UAAa,WAAW,KAAK,OAAO,EAAE,IAAI,MAAM;GAEjE,IAAI,QAAQ,GAAG,OAAO;IAAE,IAAI;IAAM,OAAO,CAAC;GAAE;GAC5C,MAAM,OAAO,sBAAsB,KAAK,KAAK;GAE7C,IAAI,CAAC,KAAK,IAAI,OAAO,EAAE,IAAI,MAAM;GAIjC,OAAO;IAAE,IAAI;IAAM,OAAO,MAAM,KAAK,EAAE,QAAQ,IAAI,SAAS,KAAK,KAAK;GAAE;EAC1E;EAEA,KAAK;EACL,KAAK,UAAU;GACb,MAAM,aAAyB,aAAa,KAAK,UAAU,IAAI,KAAK,aAAa,CAAC;GAElF,MAAM,WAAW,MAAM,QAAQ,KAAK,QAAQ,IACxC,KAAK,SAAS,SAAS,QAAQ,EAAE,OAAO,CAAC,CAAC,UAAU,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC,IACnE,CAAC;GAEL,MAAM,UAAsC,CAAC;GAE7C,KAAK,MAAM,OAAO,UAAU;IAC1B,MAAM,QAAQ,sBAAsB,WAAW,IAAI;IAEnD,IAAI,CAAC,MAAM,IAAI,OAAO,EAAE,IAAI,MAAM;IAClC,QAAQ,KAAK,CAAC,KAAK,MAAM,KAAK,CAAC;GACjC;GAEA,OAAO;IAAE,IAAI;IAAM,OAAO,OAAO,YAAY,OAAO;GAAE;EACxD;EAEA,SACE,OAAO,EAAE,IAAI,MAAM;CACvB;AACF;AAKA,SAAgB,yBAAyB,OAAoB,YAA6B;CACxF,MAAM,EAAE,iBAAiB,sBAAsB,sBAAsB,KAAK;CAE1E,MAAM,WAAW,MACd,KAAK,SAAS;EACb,MAAM,cAAc,KAAK,cAAc,MAAM,KAAK,gBAAgB;EAElE,OAAO,KAAK,KAAK,OAAO,YAAY,mBAAmB,KAAK,UAAU,KAAK,WAAW;CACxF,CAAC,CAAC,CACD,KAAK,IAAI;CAKZ,MAAM,gBACJ,eAAe,SACX;EACE;EACA;EACA;EACA;CACF,IACA;EACE;EACA;EACA;EACA;EACA;EACA;EACA;CACF;CAoBN,OAAO;EACL;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,GAAG;GAzBH,oBAAoB,SAChB,wDACA;GACJ,GAAI,oBAAoB,SACpB,CAAC,eAAe,IAChB,CACE,6DACA,kFACF;GACJ;GACA;GACA;GACA;EAaG;EACH;EACA,GAAG;EACH;EACA;EACA;CACF,CAAC,CAAC,KAAK,IAAI;AACb"}

package/bundle/dist/application/qgrid/slack-user-map.js

@@ -37,4 +37,4 @@ function getSlackUserMap(readSetting = getSetting) {
 //#endregion
 export { getSlackUserMap, mentionFor, ownerOf, parseSlackUserMap };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xhY2stdXNlci1tYXAuanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2FwcGxpY2F0aW9uL3FncmlkL3NsYWNrLXVzZXItbWFwLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICog7Yag7YGwIOyGjOycoOyekCDihpIgU2xhY2sg7IKs7Jqp7J6QIOupmOyFmC5cbiAqXG4gKiBTbGFjayDtkZzsi5wg7J2066aE6rO8IO2GoO2BsOuqheydtCDsnpDso7wg7Ja06riL64KYKGhhemXihpJoYXplLmxlZSwgYnllb25nanVu4oaScG90YWRvcykgYHVzZXJzLmxpc3RgXG4gKiDsnpDrj5kg66ek7Lmt7J2AIOyhsOyaqe2eiCDsi6TtjKjtlZzri6QuIOupmOyFmOydtCDruaDsp4DrqbQg7JWM66a87J20IOqwnOyduOyXkOqyjCDri7/sp4Ag7JWK7JWEIOuqqeyggSDsnpDssrTqsIBcbiAqIOyCrOudvOyngOuvgOuhnCBgU0xBQ0tfVVNFUl9NQVBgIOuqheyLnCDrp6TtlZHrp4wg7JO064ukLlxuICpcbiAqIOqzteyaqSDqs4TsoJUoYnlzdWNvLCBkZXYtY29tbW9uIOuTsSnsnYAg66ek7ZWR7JeQIOuEo+yngCDslYrripTri6Qg4oCUIOupmOyFmCDsl4bsnbQg7J2066aE66eMIOuCmOqwgOuKlCDqsoPsnbRcbiAqIOunnuuKlCDrj5nsnpHsnbTri6QuXG4gKi9cblxuaW1wb3J0IHsgZ2V0U2V0dGluZyB9IGZyb20gXCIuLi9zZXR0aW5nL3NldHRpbmcuc3RvcmVcIjtcblxuLyoqIGDthqDtgbDrqoU6U2xhY2tVc2VySWRgIOuqqeuhneydhCDtjIzsi7HtlZzri6QuICovXG5leHBvcnQgZnVuY3Rpb24gcGFyc2VTbGFja1VzZXJNYXAocmF3OiBzdHJpbmcgfCB1bmRlZmluZWQpOiBNYXA8c3RyaW5nLCBzdHJpbmc+IHtcbiAgY29uc3QgbWFwID0gbmV3IE1hcDxzdHJpbmcsIHN0cmluZz4oKTtcblxuICBpZiAoIXJhdykgcmV0dXJuIG1hcDtcblxuICBmb3IgKGNvbnN0IGVudHJ5IG9mIHJhdy5zcGxpdChcIixcIikpIHtcbiAgICBjb25zdCBbbmFtZSwgdXNlcklkXSA9IGVudHJ5LnNwbGl0KFwiOlwiKS5tYXAoKHMpID0+IHMudHJpbSgpKTtcblxuICAgIGlmIChuYW1lICYmIHVzZXJJZCkgbWFwLnNldChuYW1lLCB1c2VySWQpO1xuICB9XG5cbiAgcmV0dXJuIG1hcDtcbn1cblxuLyoqIGBhbnRocm9waWMveWRzYCDihpIgYHlkc2AuIHByb3ZpZGVyIHByZWZpeCDsl4bsnbQg7KCA7J6l65CcIOydtOumhOuPhCDqt7jrjIDroZwg67Cb64qU64ukLiAqL1xuZXhwb3J0IGZ1bmN0aW9uIG93bmVyT2YodG9rZW5OYW1lOiBzdHJpbmcgfCBudWxsKTogc3RyaW5nIHtcbiAgaWYgKCF0b2tlbk5hbWUpIHJldHVybiBcIlwiO1xuICBjb25zdCBzbGFzaCA9IHRva2VuTmFtZS5pbmRleE9mKFwiL1wiKTtcblxuICByZXR1cm4gc2xhc2ggPT09IC0xID8gdG9rZW5OYW1lIDogdG9rZW5OYW1lLnNsaWNlKHNsYXNoICsgMSk7XG59XG5cbi8qKiDrp6TtlZHsnbQg7J6I7Jy866m0IGA8QFUuLi4+YCwg7JeG7Jy866m0IOu5iCDrrLjsnpDsl7QuIO2YuOy2nOu2gOqwgCDrqZjshZgg7Jyg66y066GcIOusuOq1rOulvCDqs6Drpbjri6QuICovXG5leHBvcnQgZnVuY3Rpb24gbWVudGlvbkZvcih0b2tlbk5hbWU6IHN0cmluZyB8IG51bGwsIHVzZXJNYXA6IE1hcDxzdHJpbmcsIHN0cmluZz4pOiBzdHJpbmcge1xuICBjb25zdCB1c2VySWQgPSB1c2VyTWFwLmdldChvd25lck9mKHRva2VuTmFtZSkpO1xuXG4gIHJldHVybiB1c2VySWQgPyBgPEAke3VzZXJJZH0+YCA6IFwiXCI7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBnZXRTbGFja1VzZXJNYXAocmVhZFNldHRpbmc6IHR5cGVvZiBnZXRTZXR0aW5nID0gZ2V0U2V0dGluZyk6IE1hcDxzdHJpbmcsIHN0cmluZz4ge1xuICByZXR1cm4gcGFyc2VTbGFja1VzZXJNYXAocmVhZFNldHRpbmcoXCJzbGFjay51c2VyTWFwXCIsIFwiU0xBQ0tfVVNFUl9NQVBcIikpO1xufVxuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7O0FBY0EsU0FBZ0Isa0JBQWtCLEtBQThDO0NBQzlFLE1BQU0sc0JBQU0sSUFBSSxJQUFvQjtDQUVwQyxJQUFJLENBQUMsS0FBSyxPQUFPO0NBRWpCLEtBQUssTUFBTSxTQUFTLElBQUksTUFBTSxHQUFHLEdBQUc7RUFDbEMsTUFBTSxDQUFDLE1BQU0sVUFBVSxNQUFNLE1BQU0sR0FBRyxDQUFDLENBQUMsS0FBSyxNQUFNLEVBQUUsS0FBSyxDQUFDO0VBRTNELElBQUksUUFBUSxRQUFRLElBQUksSUFBSSxNQUFNLE1BQU07Q0FDMUM7Q0FFQSxPQUFPO0FBQ1Q7O0FBR0EsU0FBZ0IsUUFBUSxXQUFrQztDQUN4RCxJQUFJLENBQUMsV0FBVyxPQUFPO0NBQ3ZCLE1BQU0sUUFBUSxVQUFVLFFBQVEsR0FBRztDQUVuQyxPQUFPLFVBQVUsS0FBSyxZQUFZLFVBQVUsTUFBTSxRQUFRLENBQUM7QUFDN0Q7O0FBR0EsU0FBZ0IsV0FBVyxXQUEwQixTQUFzQztDQUN6RixNQUFNLFNBQVMsUUFBUSxJQUFJLFFBQVEsU0FBUyxDQUFDO0NBRTdDLE9BQU8sU0FBUyxLQUFLLE9BQU8sS0FBSztBQUNuQztBQUVBLFNBQWdCLGdCQUFnQixjQUFpQyxZQUFpQztDQUNoRyxPQUFPLGtCQUFrQixZQUFZLGlCQUFpQixnQkFBZ0IsQ0FBQztBQUN6RSJ9

package/bundle/dist/application/qgrid/token-death.js

@@ -56,4 +56,4 @@ function notifyTokenAdded(name, provider) {
 //#endregion
 export { deactivateAuthDeadToken, notifyTokenAdded };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9rZW4tZGVhdGguanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2FwcGxpY2F0aW9uL3FncmlkL3Rva2VuLWRlYXRoLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICog7IS47IWYIOunjOujjChhdXRoLWRlYWQpIO2GoO2BsOydmCDrnbzsmrDtjIUg7KCc7Jm4IOyngOygkC5cbiAqXG4gKiByZWZyZXNoIOqwgCDsnqzroZzqt7jsnbgg7Jm4IOuzteq1rCDrtojqsIDtlZwg7Iuk7Yyo66W8IOuwmO2ZmO2VnCDsiJzqsITsl5Drp4wg7Zi47Lac65Cc64ukLiDsi5zrj4Tsl5Ag7IKs7Jqp7ZWcXG4gKiBjcmVkZW50aWFscyDqsIAgREIg7JmAIOqwmeydhCDrlYzrp4wgcmVhdXRoX3JlcXVpcmVkIOulvCDquLDroZ3tlZjqs6AsIOq3uCDquLDroZ3snYQg7J206ri0IO2UhOuhnOyEuOyKpOunjFxuICogU2xhY2sg7JWM66a87J2EIOuztOuCuOuLpCDigJQg6rO17JygIERCIOulvCDsk7DripQg7J247Iqk7YS07Iqk6rCAIOuqh+ydtOuToCDsgqzqsbTri7kg7JWM66a87J2AIDHqsbTsnbTri6QuXG4gKi9cbmltcG9ydCB7IGdldExvZ2dlciB9IGZyb20gXCJAbG9ndGFwZS9sb2d0YXBlXCI7XG5cbmltcG9ydCB7IG5vdGlmeVNsYWNrLCBTTEFDS19DT0xPUiB9IGZyb20gXCIuLi8uLi91dGlscy9zbGFjay1ub3RpZnlcIjtcbmltcG9ydCB7IHR5cGUgVG9rZW5TdWJzZXRBIH0gZnJvbSBcIi4uL3NvbmFtdS5nZW5lcmF0ZWRcIjtcbmltcG9ydCB7IFRva2VuTW9kZWwgfSBmcm9tIFwiLi4vdG9rZW4vdG9rZW4ubW9kZWxcIjtcbmltcG9ydCB7IGdldFNsYWNrVXNlck1hcCwgbWVudGlvbkZvciB9IGZyb20gXCIuL3NsYWNrLXVzZXItbWFwXCI7XG5cbmNvbnN0IGxvZ2dlciA9IGdldExvZ2dlcihbXCJxZ3JpZFwiLCBcInRva2VuLWRlYXRoXCJdKTtcblxudHlwZSBEZWFkVG9rZW5SZWYgPSBQaWNrPFRva2VuU3Vic2V0QSwgXCJpZFwiIHwgXCJuYW1lXCIgfCBcInByb3ZpZGVyXCIgfCBcImNyZWRlbnRpYWxzXCI+O1xuXG4vKipcbiAqIEBwYXJhbSByZWFzb25Db2RlIGBwcm92aWRlcjpjb2RlYCDtmJXtg5zsnZgg64K067aAIOy9lOuTnC4gcHJvdmlkZXIg7J2R64u1IOuzuOusuOyXkOuKlCDqs4TsoJUg7J2066mU7J287J2064KYXG4gKiAgIO2GoO2BsCDsobDqsIHsnbQg7ISe7J28IOyImCDsnojslrQgcmF3IOuplOyLnOyngOulvCDqt7jrjIDroZwg7JWM66a87JeQIOyLo+yngCDslYrripTri6QuXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBkZWFjdGl2YXRlQXV0aERlYWRUb2tlbihcbiAgdG9rZW46IERlYWRUb2tlblJlZixcbiAgcmVhc29uQ29kZTogc3RyaW5nLFxuKTogUHJvbWlzZTxib29sZWFuPiB7XG4gIGNvbnN0IHsgbWFya2VkLCB3YXNMYXN0QWN0aXZlLCBzdGFsZUNyZWRlbnRpYWxzIH0gPSBhd2FpdCBUb2tlbk1vZGVsLm1hcmtSZWF1dGhSZXF1aXJlZChcbiAgICB0b2tlbi5pZCxcbiAgICB0b2tlbi5jcmVkZW50aWFscyxcbiAgKTtcbiAgaWYgKHN0YWxlQ3JlZGVudGlhbHMpIHtcbiAgICBsb2dnZXIuaW5mbyhcbiAgICAgIGBza2lwcGluZyBhdXRoLWRlYXRoIGZvciAke3Rva2VuLm5hbWV9KGlkPSR7dG9rZW4uaWR9KTogY3JlZGVudGlhbHMgcm90YXRlZCBzaW5jZSB0aGlzIGF0dGVtcHRgLFxuICAgICk7XG4gICAgcmV0dXJuIGZhbHNlO1xuICB9XG4gIGlmICghbWFya2VkKSByZXR1cm4gZmFsc2U7XG5cbiAgbG9nZ2VyLndhcm4oYHRva2VuIHJlcXVpcmVzIHJlLWxvZ2luOiAke3Rva2VuLm5hbWV9KGlkPSR7dG9rZW4uaWR9KSByZWFzb249JHtyZWFzb25Db2RlfWApO1xuICAvLyDrp4zro4wg7KeB7ZuE6rCAIOyerOuhnOq3uOyduO2VmOq4sCDqsIDsnqUg7KKL7J2AIO2DgOydtOuwjeydtOuLpC4g7IaM7Jyg7J6Q66W8IOupmOyFmO2VtCDqt7gg7Iic6rCEIOuLueyCrOyekOyXkOqyjFxuICAvLyDqvYLripTri6Qg4oCUIOuLpOydtOygnOyKpO2KuOulvCDquLDri6TrpqzrqbQg64uk7J2MIOyjvOq4sOq5jOyngCDthqDtgbDsnbQg67mg7KeEIOyxhOuhnCDrgqjripTri6QuXG4gIGNvbnN0IG1lbnRpb24gPSBtZW50aW9uRm9yKHRva2VuLm5hbWUsIGdldFNsYWNrVXNlck1hcCgpKTtcbiAgdm9pZCBub3RpZnlTbGFjayh7XG4gICAgdGl0bGU6IFwi7IS47IWYIOunjOujjFwiLFxuICAgIHN1YmplY3Q6IHRva2VuLm5hbWUsXG4gICAgY29udGV4dDogW1xuICAgICAgbWVudGlvbixcbiAgICAgIHRva2VuLnByb3ZpZGVyLFxuICAgICAgcmVhc29uQ29kZSxcbiAgICAgIFwi7J6s66Gc6re47J247J20IO2VhOyalO2VqeuLiOuLpFwiLFxuICAgICAgd2FzTGFzdEFjdGl2ZSA/IFwi7IKs7JqpIOqwgOuKpe2VnCDthqDtgbDsnbQg7JeG7Iq164uI64ukXCIgOiBudWxsLFxuICAgIF1cbiAgICAgIC5maWx0ZXIoQm9vbGVhbilcbiAgICAgIC5qb2luKFwiIMK3IFwiKSxcbiAgICBjb2xvcjogU0xBQ0tfQ09MT1IuYmFkLFxuICAgIHVyZ2VudDogd2FzTGFzdEFjdGl2ZSxcbiAgfSk7XG4gIHJldHVybiB0cnVlO1xufVxuXG4vKiog66Gc6re47J247J20IOyZhOujjOuPvCDthqDtgbDsnbQg7KCA7J6l65CQ7J2EIOuVjC4g7Iug6recwrfsnqzroZzqt7jsnbjsnYQg6rCA66as7KeAIOyViuuKlOuLpC4gKi9cbmV4cG9ydCBmdW5jdGlvbiBub3RpZnlUb2tlbkFkZGVkKG5hbWU6IHN0cmluZywgcHJvdmlkZXI6IHN0cmluZyk6IHZvaWQge1xuICBsb2dnZXIuaW5mbyhgdG9rZW4gYWRkZWQ6ICR7bmFtZX0gKCR7cHJvdmlkZXJ9KWApO1xuICBjb25zdCBtZW50aW9uID0gbWVudGlvbkZvcihuYW1lLCBnZXRTbGFja1VzZXJNYXAoKSk7XG4gIHZvaWQgbm90aWZ5U2xhY2soe1xuICAgIHRpdGxlOiBcIu2GoO2BsCDstpTqsIBcIixcbiAgICBzdWJqZWN0OiBuYW1lLFxuICAgIGNvbnRleHQ6IFttZW50aW9uLCBwcm92aWRlciwgXCLsmpTssq0g7LKY66as7JeQIOyCrOyaqeuQqeuLiOuLpFwiXS5maWx0ZXIoQm9vbGVhbikuam9pbihcIiDCtyBcIiksXG4gICAgY29sb3I6IFNMQUNLX0NPTE9SLmdvb2QsXG4gIH0pO1xufVxuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFjQSxNQUFNLFNBQVMsVUFBVSxDQUFDLFNBQVMsYUFBYSxDQUFDOzs7OztBQVFqRCxlQUFzQix3QkFDcEIsT0FDQSxZQUNrQjtDQUNsQixNQUFNLEVBQUUsUUFBUSxlQUFlLHFCQUFxQixNQUFNLFdBQVcsbUJBQ25FLE1BQU0sSUFDTixNQUFNLFdBQ1I7Q0FDQSxJQUFJLGtCQUFrQjtFQUNwQixPQUFPLEtBQ0wsMkJBQTJCLE1BQU0sS0FBSyxNQUFNLE1BQU0sR0FBRywwQ0FDdkQ7RUFDQSxPQUFPO0NBQ1Q7Q0FDQSxJQUFJLENBQUMsUUFBUSxPQUFPO0NBRXBCLE9BQU8sS0FBSyw0QkFBNEIsTUFBTSxLQUFLLE1BQU0sTUFBTSxHQUFHLFdBQVcsWUFBWTtDQUd6RixNQUFNLFVBQVUsV0FBVyxNQUFNLE1BQU0sZ0JBQWdCLENBQUM7Q0FDeEQsQUFBSyxZQUFZO0VBQ2YsT0FBTztFQUNQLFNBQVMsTUFBTTtFQUNmLFNBQVM7R0FDUDtHQUNBLE1BQU07R0FDTjtHQUNBO0dBQ0EsZ0JBQWdCLG9CQUFvQjtFQUN0QyxDQUFDLENBQ0UsT0FBTyxPQUFPLENBQUMsQ0FDZixLQUFLLEtBQUs7RUFDYixPQUFPLFlBQVk7RUFDbkIsUUFBUTtDQUNWLENBQUM7Q0FDRCxPQUFPO0FBQ1Q7O0FBR0EsU0FBZ0IsaUJBQWlCLE1BQWMsVUFBd0I7Q0FDckUsT0FBTyxLQUFLLGdCQUFnQixLQUFLLElBQUksU0FBUyxFQUFFO0NBRWhELEFBQUssWUFBWTtFQUNmLE9BQU87RUFDUCxTQUFTO0VBQ1QsU0FBUztHQUpLLFdBQVcsTUFBTSxnQkFBZ0IsQ0FJckM7R0FBUztHQUFVO0VBQWMsQ0FBQyxDQUFDLE9BQU8sT0FBTyxDQUFDLENBQUMsS0FBSyxLQUFLO0VBQ3ZFLE9BQU8sWUFBWTtDQUNyQixDQUFDO0FBQ0gifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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