@nhtio/adk 1.20260607.2 → 1.20260609.0

package/dispatch_runner.cjs

@@ -1,4 +1,4 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("./chunk-Ble4zEEl.js");
-const require_dispatch_runner = require("./dispatch_runner-BHBNupqp.js");
+const require_dispatch_runner = require("./dispatch_runner-nHDKkxye.js");
 exports.DispatchRunner = require_dispatch_runner.DispatchRunner;

package/dispatch_runner.d.ts

@@ -14,4 +14,4 @@ export type { RawDispatchRunnerInput } from "./lib/dispatch_runner";
 /**
  * @primaryExport
  */
-export type { DispatchPipelineMiddlewareFn, DispatchExecutorFn, DispatchExecutorHelpers, DispatchExecutorLogChannel, DispatchExecutorLogEntry, DispatchExecutorLogLevel, LogEvent, DispatchStartEvent, DispatchEndEvent, IterationStartEvent, IterationEndEvent, DispatchRunnerFunctionalHooks, DispatchRunnerObservabilityHooks, DispatchRunnerFunctionalHookRegistrations, DispatchRunnerObservabilityHookRegistrations, } from "./lib/types/dispatch_runner";
+export type { DispatchPipelineMiddlewareFn, DispatchExecutorFn, DispatchExecutorHelpers, DispatchExecutorLogChannel, DispatchExecutorLogEntry, DispatchExecutorLogLevel, LogEvent, GenerationStats, GenerationStatsEvent, DispatchStartEvent, DispatchEndEvent, IterationStartEvent, IterationEndEvent, DispatchRunnerFunctionalHooks, DispatchRunnerObservabilityHooks, DispatchRunnerFunctionalHookRegistrations, DispatchRunnerObservabilityHookRegistrations, } from "./lib/types/dispatch_runner";

package/dispatch_runner.mjs

@@ -1,2 +1,2 @@
-import { t as DispatchRunner } from "./dispatch_runner-DPcS7Y_M.mjs";
+import { t as DispatchRunner } from "./dispatch_runner--ZhdDWRZ.mjs";
 export { DispatchRunner };

package/eslint/rules/artifact_tool_forbids_artifact_constructor.cjs

@@ -27,6 +27,7 @@ var literalKey = (prop) => {
 	if (prop.key.type === "Literal" && typeof prop.key.value === "string") return prop.key.value;
 };
 var isUndefinedValue = (node) => node.type === "Identifier" && node.name === "undefined";
+/** ESLint rule: flags `new ArtifactTool({ … })` that sets the forbidden `artifactConstructor` option. */
 var artifactToolForbidsArtifactConstructorRule = require_common.createRule({
 	name: "artifact-tool-forbids-artifact-constructor",
 	meta: {

package/eslint/rules/artifact_tool_forbids_artifact_constructor.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"artifact_tool_forbids_artifact_constructor.cjs","names":[],"sources":["../../../src/eslint/rules/artifact_tool_forbids_artifact_constructor.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/artifact_tool_forbids_artifact_constructor\n *\n * Flags `new ArtifactTool({ … })` whose options literal sets an `artifactConstructor`.\n *\n * Why: an `ArtifactTool` is the tool that answers queries AGAINST a spooled artifact — it must not\n * itself return a `SpooledArtifact`, or the result would be re-wrapped into another artifact whose\n * query tools are themselves `ArtifactTool`s, and so on without end. The base `RawTool` accepts an\n * `artifactConstructor` (the subclass used to wrap a tool's bytes), but `ArtifactTool` explicitly\n * FORBIDS it (`artifactConstructor: validator.any().forbidden()` in its schema). Supplying one is a\n * recursion footgun the constructor rejects at runtime; this rule surfaces it at the construction\n * site so it fails lint.\n *\n * Opt-out:\n *   // eslint-disable-next-line adk/artifact-tool-forbids-artifact-constructor -- <reason>\n */\n\nimport { createRule } from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\nconst literalKey = (prop: TSESTree.Property): string | undefined => {\n  if (prop.computed) return undefined\n  if (prop.key.type === 'Identifier') return prop.key.name\n  if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') return prop.key.value\n  return undefined\n}\n\nconst isUndefinedValue = (node: TSESTree.Node): boolean =>\n  node.type === 'Identifier' && node.name === 'undefined'\n\nconst artifactToolForbidsArtifactConstructorRule = createRule({\n  name: 'artifact-tool-forbids-artifact-constructor',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        'An `ArtifactTool` must not declare `artifactConstructor` — it answers queries against an artifact and cannot itself return one (infinite re-wrapping). The ArtifactTool schema forbids the field at runtime; this surfaces it at the construction site.',\n    },\n    schema: [],\n    messages: {\n      forbidArtifactConstructor:\n        '`new ArtifactTool` must not set `artifactConstructor` — an artifact-query tool cannot itself return a SpooledArtifact (it would re-wrap forever). The ArtifactTool schema forbids this field. Remove it. Opt out with an eslint-disable-next-line adk/artifact-tool-forbids-artifact-constructor comment + reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      NewExpression(node: TSESTree.NewExpression) {\n        if (node.callee.type !== 'Identifier' || node.callee.name !== 'ArtifactTool') return\n        const arg = node.arguments[0]\n        if (!arg || arg.type !== 'ObjectExpression') return\n\n        for (const p of arg.properties) {\n          if (p.type === 'SpreadElement') continue\n          if (literalKey(p) === 'artifactConstructor' && !isUndefinedValue(p.value)) {\n            context.report({ node: p, messageId: 'forbidArtifactConstructor' })\n          }\n        }\n      },\n    }\n  },\n})\n\nexport default artifactToolForbidsArtifactConstructorRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAqBA,IAAM,cAAc,SAAgD;CAClE,IAAI,KAAK,UAAU,OAAO,KAAA;CAC1B,IAAI,KAAK,IAAI,SAAS,cAAc,OAAO,KAAK,IAAI;CACpD,IAAI,KAAK,IAAI,SAAS,aAAa,OAAO,KAAK,IAAI,UAAU,UAAU,OAAO,KAAK,IAAI;AAEzF;AAEA,IAAM,oBAAoB,SACxB,KAAK,SAAS,gBAAgB,KAAK,SAAS;AAE9C,IAAM,6CAA6C,eAAA,WAAW;CAC5D,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,0PACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,2BACE,qTACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,cAAc,MAA8B;GAC1C,IAAI,KAAK,OAAO,SAAS,gBAAgB,KAAK,OAAO,SAAS,gBAAgB;GAC9E,MAAM,MAAM,KAAK,UAAU;GAC3B,IAAI,CAAC,OAAO,IAAI,SAAS,oBAAoB;GAE7C,KAAK,MAAM,KAAK,IAAI,YAAY;IAC9B,IAAI,EAAE,SAAS,iBAAiB;IAChC,IAAI,WAAW,CAAC,MAAM,yBAAyB,CAAC,iBAAiB,EAAE,KAAK,GACtE,QAAQ,OAAO;KAAE,MAAM;KAAG,WAAW;IAA4B,CAAC;GAEtE;EACF,EACF;CACF;AACF,CAAC"}
+{"version":3,"file":"artifact_tool_forbids_artifact_constructor.cjs","names":[],"sources":["../../../src/eslint/rules/artifact_tool_forbids_artifact_constructor.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/artifact_tool_forbids_artifact_constructor\n *\n * Flags `new ArtifactTool({ … })` whose options literal sets an `artifactConstructor`.\n *\n * Why: an `ArtifactTool` is the tool that answers queries AGAINST a spooled artifact — it must not\n * itself return a `SpooledArtifact`, or the result would be re-wrapped into another artifact whose\n * query tools are themselves `ArtifactTool`s, and so on without end. The base `RawTool` accepts an\n * `artifactConstructor` (the subclass used to wrap a tool's bytes), but `ArtifactTool` explicitly\n * FORBIDS it (`artifactConstructor: validator.any().forbidden()` in its schema). Supplying one is a\n * recursion footgun the constructor rejects at runtime; this rule surfaces it at the construction\n * site so it fails lint.\n *\n * Opt-out:\n *   // eslint-disable-next-line adk/artifact-tool-forbids-artifact-constructor -- <reason>\n */\n\nimport { createRule } from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\nconst literalKey = (prop: TSESTree.Property): string | undefined => {\n  if (prop.computed) return undefined\n  if (prop.key.type === 'Identifier') return prop.key.name\n  if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') return prop.key.value\n  return undefined\n}\n\nconst isUndefinedValue = (node: TSESTree.Node): boolean =>\n  node.type === 'Identifier' && node.name === 'undefined'\n\n/** ESLint rule: flags `new ArtifactTool({ … })` that sets the forbidden `artifactConstructor` option. */\nconst artifactToolForbidsArtifactConstructorRule = createRule({\n  name: 'artifact-tool-forbids-artifact-constructor',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        'An `ArtifactTool` must not declare `artifactConstructor` — it answers queries against an artifact and cannot itself return one (infinite re-wrapping). The ArtifactTool schema forbids the field at runtime; this surfaces it at the construction site.',\n    },\n    schema: [],\n    messages: {\n      forbidArtifactConstructor:\n        '`new ArtifactTool` must not set `artifactConstructor` — an artifact-query tool cannot itself return a SpooledArtifact (it would re-wrap forever). The ArtifactTool schema forbids this field. Remove it. Opt out with an eslint-disable-next-line adk/artifact-tool-forbids-artifact-constructor comment + reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      NewExpression(node: TSESTree.NewExpression) {\n        if (node.callee.type !== 'Identifier' || node.callee.name !== 'ArtifactTool') return\n        const arg = node.arguments[0]\n        if (!arg || arg.type !== 'ObjectExpression') return\n\n        for (const p of arg.properties) {\n          if (p.type === 'SpreadElement') continue\n          if (literalKey(p) === 'artifactConstructor' && !isUndefinedValue(p.value)) {\n            context.report({ node: p, messageId: 'forbidArtifactConstructor' })\n          }\n        }\n      },\n    }\n  },\n})\n\nexport default artifactToolForbidsArtifactConstructorRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAqBA,IAAM,cAAc,SAAgD;CAClE,IAAI,KAAK,UAAU,OAAO,KAAA;CAC1B,IAAI,KAAK,IAAI,SAAS,cAAc,OAAO,KAAK,IAAI;CACpD,IAAI,KAAK,IAAI,SAAS,aAAa,OAAO,KAAK,IAAI,UAAU,UAAU,OAAO,KAAK,IAAI;AAEzF;AAEA,IAAM,oBAAoB,SACxB,KAAK,SAAS,gBAAgB,KAAK,SAAS;;AAG9C,IAAM,6CAA6C,eAAA,WAAW;CAC5D,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,0PACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,2BACE,qTACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,cAAc,MAA8B;GAC1C,IAAI,KAAK,OAAO,SAAS,gBAAgB,KAAK,OAAO,SAAS,gBAAgB;GAC9E,MAAM,MAAM,KAAK,UAAU;GAC3B,IAAI,CAAC,OAAO,IAAI,SAAS,oBAAoB;GAE7C,KAAK,MAAM,KAAK,IAAI,YAAY;IAC9B,IAAI,EAAE,SAAS,iBAAiB;IAChC,IAAI,WAAW,CAAC,MAAM,yBAAyB,CAAC,iBAAiB,EAAE,KAAK,GACtE,QAAQ,OAAO;KAAE,MAAM;KAAG,WAAW;IAA4B,CAAC;GAEtE;EACF,EACF;CACF;AACF,CAAC"}

package/eslint/rules/artifact_tool_forbids_artifact_constructor.d.ts

@@ -14,6 +14,7 @@
  * Opt-out:
  *   // eslint-disable-next-line adk/artifact-tool-forbids-artifact-constructor -- <reason>
  */
+/** ESLint rule: flags `new ArtifactTool({ … })` that sets the forbidden `artifactConstructor` option. */
 declare const artifactToolForbidsArtifactConstructorRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"forbidArtifactConstructor", [
 ], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;

package/eslint/rules/artifact_tool_forbids_artifact_constructor.mjs

@@ -22,6 +22,7 @@ var literalKey = (prop) => {
 	if (prop.key.type === "Literal" && typeof prop.key.value === "string") return prop.key.value;
 };
 var isUndefinedValue = (node) => node.type === "Identifier" && node.name === "undefined";
+/** ESLint rule: flags `new ArtifactTool({ … })` that sets the forbidden `artifactConstructor` option. */
 var artifactToolForbidsArtifactConstructorRule = createRule({
 	name: "artifact-tool-forbids-artifact-constructor",
 	meta: {

package/eslint/rules/artifact_tool_forbids_artifact_constructor.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"artifact_tool_forbids_artifact_constructor.mjs","names":[],"sources":["../../../src/eslint/rules/artifact_tool_forbids_artifact_constructor.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/artifact_tool_forbids_artifact_constructor\n *\n * Flags `new ArtifactTool({ … })` whose options literal sets an `artifactConstructor`.\n *\n * Why: an `ArtifactTool` is the tool that answers queries AGAINST a spooled artifact — it must not\n * itself return a `SpooledArtifact`, or the result would be re-wrapped into another artifact whose\n * query tools are themselves `ArtifactTool`s, and so on without end. The base `RawTool` accepts an\n * `artifactConstructor` (the subclass used to wrap a tool's bytes), but `ArtifactTool` explicitly\n * FORBIDS it (`artifactConstructor: validator.any().forbidden()` in its schema). Supplying one is a\n * recursion footgun the constructor rejects at runtime; this rule surfaces it at the construction\n * site so it fails lint.\n *\n * Opt-out:\n *   // eslint-disable-next-line adk/artifact-tool-forbids-artifact-constructor -- <reason>\n */\n\nimport { createRule } from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\nconst literalKey = (prop: TSESTree.Property): string | undefined => {\n  if (prop.computed) return undefined\n  if (prop.key.type === 'Identifier') return prop.key.name\n  if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') return prop.key.value\n  return undefined\n}\n\nconst isUndefinedValue = (node: TSESTree.Node): boolean =>\n  node.type === 'Identifier' && node.name === 'undefined'\n\nconst artifactToolForbidsArtifactConstructorRule = createRule({\n  name: 'artifact-tool-forbids-artifact-constructor',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        'An `ArtifactTool` must not declare `artifactConstructor` — it answers queries against an artifact and cannot itself return one (infinite re-wrapping). The ArtifactTool schema forbids the field at runtime; this surfaces it at the construction site.',\n    },\n    schema: [],\n    messages: {\n      forbidArtifactConstructor:\n        '`new ArtifactTool` must not set `artifactConstructor` — an artifact-query tool cannot itself return a SpooledArtifact (it would re-wrap forever). The ArtifactTool schema forbids this field. Remove it. Opt out with an eslint-disable-next-line adk/artifact-tool-forbids-artifact-constructor comment + reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      NewExpression(node: TSESTree.NewExpression) {\n        if (node.callee.type !== 'Identifier' || node.callee.name !== 'ArtifactTool') return\n        const arg = node.arguments[0]\n        if (!arg || arg.type !== 'ObjectExpression') return\n\n        for (const p of arg.properties) {\n          if (p.type === 'SpreadElement') continue\n          if (literalKey(p) === 'artifactConstructor' && !isUndefinedValue(p.value)) {\n            context.report({ node: p, messageId: 'forbidArtifactConstructor' })\n          }\n        }\n      },\n    }\n  },\n})\n\nexport default artifactToolForbidsArtifactConstructorRule\n"],"mappings":";;;;;;;;;;;;;;;;;;AAqBA,IAAM,cAAc,SAAgD;CAClE,IAAI,KAAK,UAAU,OAAO,KAAA;CAC1B,IAAI,KAAK,IAAI,SAAS,cAAc,OAAO,KAAK,IAAI;CACpD,IAAI,KAAK,IAAI,SAAS,aAAa,OAAO,KAAK,IAAI,UAAU,UAAU,OAAO,KAAK,IAAI;AAEzF;AAEA,IAAM,oBAAoB,SACxB,KAAK,SAAS,gBAAgB,KAAK,SAAS;AAE9C,IAAM,6CAA6C,WAAW;CAC5D,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,0PACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,2BACE,qTACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,cAAc,MAA8B;GAC1C,IAAI,KAAK,OAAO,SAAS,gBAAgB,KAAK,OAAO,SAAS,gBAAgB;GAC9E,MAAM,MAAM,KAAK,UAAU;GAC3B,IAAI,CAAC,OAAO,IAAI,SAAS,oBAAoB;GAE7C,KAAK,MAAM,KAAK,IAAI,YAAY;IAC9B,IAAI,EAAE,SAAS,iBAAiB;IAChC,IAAI,WAAW,CAAC,MAAM,yBAAyB,CAAC,iBAAiB,EAAE,KAAK,GACtE,QAAQ,OAAO;KAAE,MAAM;KAAG,WAAW;IAA4B,CAAC;GAEtE;EACF,EACF;CACF;AACF,CAAC"}
+{"version":3,"file":"artifact_tool_forbids_artifact_constructor.mjs","names":[],"sources":["../../../src/eslint/rules/artifact_tool_forbids_artifact_constructor.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/artifact_tool_forbids_artifact_constructor\n *\n * Flags `new ArtifactTool({ … })` whose options literal sets an `artifactConstructor`.\n *\n * Why: an `ArtifactTool` is the tool that answers queries AGAINST a spooled artifact — it must not\n * itself return a `SpooledArtifact`, or the result would be re-wrapped into another artifact whose\n * query tools are themselves `ArtifactTool`s, and so on without end. The base `RawTool` accepts an\n * `artifactConstructor` (the subclass used to wrap a tool's bytes), but `ArtifactTool` explicitly\n * FORBIDS it (`artifactConstructor: validator.any().forbidden()` in its schema). Supplying one is a\n * recursion footgun the constructor rejects at runtime; this rule surfaces it at the construction\n * site so it fails lint.\n *\n * Opt-out:\n *   // eslint-disable-next-line adk/artifact-tool-forbids-artifact-constructor -- <reason>\n */\n\nimport { createRule } from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\nconst literalKey = (prop: TSESTree.Property): string | undefined => {\n  if (prop.computed) return undefined\n  if (prop.key.type === 'Identifier') return prop.key.name\n  if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') return prop.key.value\n  return undefined\n}\n\nconst isUndefinedValue = (node: TSESTree.Node): boolean =>\n  node.type === 'Identifier' && node.name === 'undefined'\n\n/** ESLint rule: flags `new ArtifactTool({ … })` that sets the forbidden `artifactConstructor` option. */\nconst artifactToolForbidsArtifactConstructorRule = createRule({\n  name: 'artifact-tool-forbids-artifact-constructor',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        'An `ArtifactTool` must not declare `artifactConstructor` — it answers queries against an artifact and cannot itself return one (infinite re-wrapping). The ArtifactTool schema forbids the field at runtime; this surfaces it at the construction site.',\n    },\n    schema: [],\n    messages: {\n      forbidArtifactConstructor:\n        '`new ArtifactTool` must not set `artifactConstructor` — an artifact-query tool cannot itself return a SpooledArtifact (it would re-wrap forever). The ArtifactTool schema forbids this field. Remove it. Opt out with an eslint-disable-next-line adk/artifact-tool-forbids-artifact-constructor comment + reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      NewExpression(node: TSESTree.NewExpression) {\n        if (node.callee.type !== 'Identifier' || node.callee.name !== 'ArtifactTool') return\n        const arg = node.arguments[0]\n        if (!arg || arg.type !== 'ObjectExpression') return\n\n        for (const p of arg.properties) {\n          if (p.type === 'SpreadElement') continue\n          if (literalKey(p) === 'artifactConstructor' && !isUndefinedValue(p.value)) {\n            context.report({ node: p, messageId: 'forbidArtifactConstructor' })\n          }\n        }\n      },\n    }\n  },\n})\n\nexport default artifactToolForbidsArtifactConstructorRule\n"],"mappings":";;;;;;;;;;;;;;;;;;AAqBA,IAAM,cAAc,SAAgD;CAClE,IAAI,KAAK,UAAU,OAAO,KAAA;CAC1B,IAAI,KAAK,IAAI,SAAS,cAAc,OAAO,KAAK,IAAI;CACpD,IAAI,KAAK,IAAI,SAAS,aAAa,OAAO,KAAK,IAAI,UAAU,UAAU,OAAO,KAAK,IAAI;AAEzF;AAEA,IAAM,oBAAoB,SACxB,KAAK,SAAS,gBAAgB,KAAK,SAAS;;AAG9C,IAAM,6CAA6C,WAAW;CAC5D,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,0PACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,2BACE,qTACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,cAAc,MAA8B;GAC1C,IAAI,KAAK,OAAO,SAAS,gBAAgB,KAAK,OAAO,SAAS,gBAAgB;GAC9E,MAAM,MAAM,KAAK,UAAU;GAC3B,IAAI,CAAC,OAAO,IAAI,SAAS,oBAAoB;GAE7C,KAAK,MAAM,KAAK,IAAI,YAAY;IAC9B,IAAI,EAAE,SAAS,iBAAiB;IAChC,IAAI,WAAW,CAAC,MAAM,yBAAyB,CAAC,iBAAiB,EAAE,KAAK,GACtE,QAAQ,OAAO;KAAE,MAAM;KAAG,WAAW;IAA4B,CAAC;GAEtE;EACF,EACF;CACF;AACF,CAAC"}

package/eslint/rules/no_model_in_tool_handler.cjs

@@ -31,6 +31,7 @@ var literalKey = (prop) => {
 	if (prop.key.type === "Identifier") return prop.key.name;
 	if (prop.key.type === "Literal" && typeof prop.key.value === "string") return prop.key.value;
 };
+/** ESLint rule: flags referencing the model or LLM adapter inside a tool handler. */
 var noModelInToolHandlerRule = require_common.createRule({
 	name: "no-model-in-tool-handler",
 	meta: {

package/eslint/rules/no_model_in_tool_handler.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"no_model_in_tool_handler.cjs","names":[],"sources":["../../../src/eslint/rules/no_model_in_tool_handler.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/no_model_in_tool_handler\n *\n * Flags an LLM/model call inside a `Tool` / `ArtifactTool` `handler`.\n *\n * Why: the executor owns the dispatch loop. A tool handler runs as one step the model proposed; it\n * must do work and return a result, not start its own reasoning loop. Calling a model from inside a\n * handler hides a nested, unmanaged dispatch from the harness — no token accounting, no event\n * surfacing, no abort propagation. The one legitimate exception is a tool that is explicitly a\n * sub-agent running its own scoped dispatch; this rule allows a handler that constructs a\n * `new TurnRunner(...)` or calls the lower-level `DispatchRunner.dispatch(...)`.\n *\n * Detects provider SDK constructors (`new OpenAI()`, `new Anthropic()`) and chat/completion calls\n * (a `.create()` whose receiver chain passes through `messages`/`completions`/`responses`, or a\n * `generateContent()` call) within the `handler` function passed to `new Tool({ handler })` /\n * `new ArtifactTool({ handler })`, ignoring inner closures (so a sub-agent's own callbacks don't\n * false-positive).\n *\n * Opt-out:\n *   // eslint-disable-next-line adk/no-model-in-tool-handler -- <reason>\n */\n\nimport {\n  createRule,\n  isFunctionNode,\n  isLlmCall,\n  runsSubAgent,\n  walkBodySkippingNestedFunctions,\n} from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\nconst literalKey = (prop: TSESTree.Property): string | undefined => {\n  if (prop.computed) return undefined\n  if (prop.key.type === 'Identifier') return prop.key.name\n  if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') return prop.key.value\n  return undefined\n}\n\nconst noModelInToolHandlerRule = createRule({\n  name: 'no-model-in-tool-handler',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        'A Tool/ArtifactTool handler must not invoke a model — the executor owns the dispatch loop. The only exception is a sub-agent tool that runs its own scoped dispatch via `new TurnRunner(...)` or `DispatchRunner.dispatch(...)`.',\n    },\n    schema: [],\n    messages: {\n      noModelInHandler:\n        'Do not call a model inside a tool handler — the executor owns the dispatch loop, and a model call here hides an unmanaged nested dispatch (no token accounting, events, or abort). If this tool is a sub-agent, run a scoped `new TurnRunner(...)` or `DispatchRunner.dispatch(...)` instead. Opt out with an eslint-disable-next-line adk/no-model-in-tool-handler comment + reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      NewExpression(node: TSESTree.NewExpression) {\n        if (\n          node.callee.type !== 'Identifier' ||\n          (node.callee.name !== 'Tool' && node.callee.name !== 'ArtifactTool')\n        ) {\n          return\n        }\n        const arg = node.arguments[0]\n        if (!arg || arg.type !== 'ObjectExpression') return\n\n        const handlerProp = arg.properties.find(\n          (p): p is TSESTree.Property => p.type === 'Property' && literalKey(p) === 'handler'\n        )\n        if (!handlerProp || !isFunctionNode(handlerProp.value)) return\n        const handler = handlerProp.value\n\n        // A sub-agent tool legitimately runs a scoped dispatch (new TurnRunner / DispatchRunner.dispatch)\n        // — that's the documented exception.\n        if (runsSubAgent(handler.body)) return\n\n        walkBodySkippingNestedFunctions(handler.body, (n) => {\n          if (isLlmCall(n)) {\n            context.report({ node: n, messageId: 'noModelInHandler' })\n          }\n        })\n      },\n    }\n  },\n})\n\nexport default noModelInToolHandlerRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,IAAM,cAAc,SAAgD;CAClE,IAAI,KAAK,UAAU,OAAO,KAAA;CAC1B,IAAI,KAAK,IAAI,SAAS,cAAc,OAAO,KAAK,IAAI;CACpD,IAAI,KAAK,IAAI,SAAS,aAAa,OAAO,KAAK,IAAI,UAAU,UAAU,OAAO,KAAK,IAAI;AAEzF;AAEA,IAAM,2BAA2B,eAAA,WAAW;CAC1C,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,mOACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,kBACE,wXACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,cAAc,MAA8B;GAC1C,IACE,KAAK,OAAO,SAAS,gBACpB,KAAK,OAAO,SAAS,UAAU,KAAK,OAAO,SAAS,gBAErD;GAEF,MAAM,MAAM,KAAK,UAAU;GAC3B,IAAI,CAAC,OAAO,IAAI,SAAS,oBAAoB;GAE7C,MAAM,cAAc,IAAI,WAAW,MAChC,MAA8B,EAAE,SAAS,cAAc,WAAW,CAAC,MAAM,SAC5E;GACA,IAAI,CAAC,eAAe,CAAC,eAAA,eAAe,YAAY,KAAK,GAAG;GACxD,MAAM,UAAU,YAAY;GAI5B,IAAI,eAAA,aAAa,QAAQ,IAAI,GAAG;GAEhC,eAAA,gCAAgC,QAAQ,OAAO,MAAM;IACnD,IAAI,eAAA,UAAU,CAAC,GACb,QAAQ,OAAO;KAAE,MAAM;KAAG,WAAW;IAAmB,CAAC;GAE7D,CAAC;EACH,EACF;CACF;AACF,CAAC"}
+{"version":3,"file":"no_model_in_tool_handler.cjs","names":[],"sources":["../../../src/eslint/rules/no_model_in_tool_handler.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/no_model_in_tool_handler\n *\n * Flags an LLM/model call inside a `Tool` / `ArtifactTool` `handler`.\n *\n * Why: the executor owns the dispatch loop. A tool handler runs as one step the model proposed; it\n * must do work and return a result, not start its own reasoning loop. Calling a model from inside a\n * handler hides a nested, unmanaged dispatch from the harness — no token accounting, no event\n * surfacing, no abort propagation. The one legitimate exception is a tool that is explicitly a\n * sub-agent running its own scoped dispatch; this rule allows a handler that constructs a\n * `new TurnRunner(...)` or calls the lower-level `DispatchRunner.dispatch(...)`.\n *\n * Detects provider SDK constructors (`new OpenAI()`, `new Anthropic()`) and chat/completion calls\n * (a `.create()` whose receiver chain passes through `messages`/`completions`/`responses`, or a\n * `generateContent()` call) within the `handler` function passed to `new Tool({ handler })` /\n * `new ArtifactTool({ handler })`, ignoring inner closures (so a sub-agent's own callbacks don't\n * false-positive).\n *\n * Opt-out:\n *   // eslint-disable-next-line adk/no-model-in-tool-handler -- <reason>\n */\n\nimport {\n  createRule,\n  isFunctionNode,\n  isLlmCall,\n  runsSubAgent,\n  walkBodySkippingNestedFunctions,\n} from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\nconst literalKey = (prop: TSESTree.Property): string | undefined => {\n  if (prop.computed) return undefined\n  if (prop.key.type === 'Identifier') return prop.key.name\n  if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') return prop.key.value\n  return undefined\n}\n\n/** ESLint rule: flags referencing the model or LLM adapter inside a tool handler. */\nconst noModelInToolHandlerRule = createRule({\n  name: 'no-model-in-tool-handler',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        'A Tool/ArtifactTool handler must not invoke a model — the executor owns the dispatch loop. The only exception is a sub-agent tool that runs its own scoped dispatch via `new TurnRunner(...)` or `DispatchRunner.dispatch(...)`.',\n    },\n    schema: [],\n    messages: {\n      noModelInHandler:\n        'Do not call a model inside a tool handler — the executor owns the dispatch loop, and a model call here hides an unmanaged nested dispatch (no token accounting, events, or abort). If this tool is a sub-agent, run a scoped `new TurnRunner(...)` or `DispatchRunner.dispatch(...)` instead. Opt out with an eslint-disable-next-line adk/no-model-in-tool-handler comment + reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      NewExpression(node: TSESTree.NewExpression) {\n        if (\n          node.callee.type !== 'Identifier' ||\n          (node.callee.name !== 'Tool' && node.callee.name !== 'ArtifactTool')\n        ) {\n          return\n        }\n        const arg = node.arguments[0]\n        if (!arg || arg.type !== 'ObjectExpression') return\n\n        const handlerProp = arg.properties.find(\n          (p): p is TSESTree.Property => p.type === 'Property' && literalKey(p) === 'handler'\n        )\n        if (!handlerProp || !isFunctionNode(handlerProp.value)) return\n        const handler = handlerProp.value\n\n        // A sub-agent tool legitimately runs a scoped dispatch (new TurnRunner / DispatchRunner.dispatch)\n        // — that's the documented exception.\n        if (runsSubAgent(handler.body)) return\n\n        walkBodySkippingNestedFunctions(handler.body, (n) => {\n          if (isLlmCall(n)) {\n            context.report({ node: n, messageId: 'noModelInHandler' })\n          }\n        })\n      },\n    }\n  },\n})\n\nexport default noModelInToolHandlerRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,IAAM,cAAc,SAAgD;CAClE,IAAI,KAAK,UAAU,OAAO,KAAA;CAC1B,IAAI,KAAK,IAAI,SAAS,cAAc,OAAO,KAAK,IAAI;CACpD,IAAI,KAAK,IAAI,SAAS,aAAa,OAAO,KAAK,IAAI,UAAU,UAAU,OAAO,KAAK,IAAI;AAEzF;;AAGA,IAAM,2BAA2B,eAAA,WAAW;CAC1C,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,mOACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,kBACE,wXACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,cAAc,MAA8B;GAC1C,IACE,KAAK,OAAO,SAAS,gBACpB,KAAK,OAAO,SAAS,UAAU,KAAK,OAAO,SAAS,gBAErD;GAEF,MAAM,MAAM,KAAK,UAAU;GAC3B,IAAI,CAAC,OAAO,IAAI,SAAS,oBAAoB;GAE7C,MAAM,cAAc,IAAI,WAAW,MAChC,MAA8B,EAAE,SAAS,cAAc,WAAW,CAAC,MAAM,SAC5E;GACA,IAAI,CAAC,eAAe,CAAC,eAAA,eAAe,YAAY,KAAK,GAAG;GACxD,MAAM,UAAU,YAAY;GAI5B,IAAI,eAAA,aAAa,QAAQ,IAAI,GAAG;GAEhC,eAAA,gCAAgC,QAAQ,OAAO,MAAM;IACnD,IAAI,eAAA,UAAU,CAAC,GACb,QAAQ,OAAO;KAAE,MAAM;KAAG,WAAW;IAAmB,CAAC;GAE7D,CAAC;EACH,EACF;CACF;AACF,CAAC"}

package/eslint/rules/no_model_in_tool_handler.d.ts

@@ -19,6 +19,7 @@
  * Opt-out:
  *   // eslint-disable-next-line adk/no-model-in-tool-handler -- <reason>
  */
+/** ESLint rule: flags referencing the model or LLM adapter inside a tool handler. */
 declare const noModelInToolHandlerRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noModelInHandler", [
 ], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;

package/eslint/rules/no_model_in_tool_handler.mjs

@@ -26,6 +26,7 @@ var literalKey = (prop) => {
 	if (prop.key.type === "Identifier") return prop.key.name;
 	if (prop.key.type === "Literal" && typeof prop.key.value === "string") return prop.key.value;
 };
+/** ESLint rule: flags referencing the model or LLM adapter inside a tool handler. */
 var noModelInToolHandlerRule = createRule({
 	name: "no-model-in-tool-handler",
 	meta: {

package/eslint/rules/no_model_in_tool_handler.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"no_model_in_tool_handler.mjs","names":[],"sources":["../../../src/eslint/rules/no_model_in_tool_handler.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/no_model_in_tool_handler\n *\n * Flags an LLM/model call inside a `Tool` / `ArtifactTool` `handler`.\n *\n * Why: the executor owns the dispatch loop. A tool handler runs as one step the model proposed; it\n * must do work and return a result, not start its own reasoning loop. Calling a model from inside a\n * handler hides a nested, unmanaged dispatch from the harness — no token accounting, no event\n * surfacing, no abort propagation. The one legitimate exception is a tool that is explicitly a\n * sub-agent running its own scoped dispatch; this rule allows a handler that constructs a\n * `new TurnRunner(...)` or calls the lower-level `DispatchRunner.dispatch(...)`.\n *\n * Detects provider SDK constructors (`new OpenAI()`, `new Anthropic()`) and chat/completion calls\n * (a `.create()` whose receiver chain passes through `messages`/`completions`/`responses`, or a\n * `generateContent()` call) within the `handler` function passed to `new Tool({ handler })` /\n * `new ArtifactTool({ handler })`, ignoring inner closures (so a sub-agent's own callbacks don't\n * false-positive).\n *\n * Opt-out:\n *   // eslint-disable-next-line adk/no-model-in-tool-handler -- <reason>\n */\n\nimport {\n  createRule,\n  isFunctionNode,\n  isLlmCall,\n  runsSubAgent,\n  walkBodySkippingNestedFunctions,\n} from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\nconst literalKey = (prop: TSESTree.Property): string | undefined => {\n  if (prop.computed) return undefined\n  if (prop.key.type === 'Identifier') return prop.key.name\n  if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') return prop.key.value\n  return undefined\n}\n\nconst noModelInToolHandlerRule = createRule({\n  name: 'no-model-in-tool-handler',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        'A Tool/ArtifactTool handler must not invoke a model — the executor owns the dispatch loop. The only exception is a sub-agent tool that runs its own scoped dispatch via `new TurnRunner(...)` or `DispatchRunner.dispatch(...)`.',\n    },\n    schema: [],\n    messages: {\n      noModelInHandler:\n        'Do not call a model inside a tool handler — the executor owns the dispatch loop, and a model call here hides an unmanaged nested dispatch (no token accounting, events, or abort). If this tool is a sub-agent, run a scoped `new TurnRunner(...)` or `DispatchRunner.dispatch(...)` instead. Opt out with an eslint-disable-next-line adk/no-model-in-tool-handler comment + reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      NewExpression(node: TSESTree.NewExpression) {\n        if (\n          node.callee.type !== 'Identifier' ||\n          (node.callee.name !== 'Tool' && node.callee.name !== 'ArtifactTool')\n        ) {\n          return\n        }\n        const arg = node.arguments[0]\n        if (!arg || arg.type !== 'ObjectExpression') return\n\n        const handlerProp = arg.properties.find(\n          (p): p is TSESTree.Property => p.type === 'Property' && literalKey(p) === 'handler'\n        )\n        if (!handlerProp || !isFunctionNode(handlerProp.value)) return\n        const handler = handlerProp.value\n\n        // A sub-agent tool legitimately runs a scoped dispatch (new TurnRunner / DispatchRunner.dispatch)\n        // — that's the documented exception.\n        if (runsSubAgent(handler.body)) return\n\n        walkBodySkippingNestedFunctions(handler.body, (n) => {\n          if (isLlmCall(n)) {\n            context.report({ node: n, messageId: 'noModelInHandler' })\n          }\n        })\n      },\n    }\n  },\n})\n\nexport default noModelInToolHandlerRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAgCA,IAAM,cAAc,SAAgD;CAClE,IAAI,KAAK,UAAU,OAAO,KAAA;CAC1B,IAAI,KAAK,IAAI,SAAS,cAAc,OAAO,KAAK,IAAI;CACpD,IAAI,KAAK,IAAI,SAAS,aAAa,OAAO,KAAK,IAAI,UAAU,UAAU,OAAO,KAAK,IAAI;AAEzF;AAEA,IAAM,2BAA2B,WAAW;CAC1C,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,mOACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,kBACE,wXACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,cAAc,MAA8B;GAC1C,IACE,KAAK,OAAO,SAAS,gBACpB,KAAK,OAAO,SAAS,UAAU,KAAK,OAAO,SAAS,gBAErD;GAEF,MAAM,MAAM,KAAK,UAAU;GAC3B,IAAI,CAAC,OAAO,IAAI,SAAS,oBAAoB;GAE7C,MAAM,cAAc,IAAI,WAAW,MAChC,MAA8B,EAAE,SAAS,cAAc,WAAW,CAAC,MAAM,SAC5E;GACA,IAAI,CAAC,eAAe,CAAC,eAAe,YAAY,KAAK,GAAG;GACxD,MAAM,UAAU,YAAY;GAI5B,IAAI,aAAa,QAAQ,IAAI,GAAG;GAEhC,gCAAgC,QAAQ,OAAO,MAAM;IACnD,IAAI,UAAU,CAAC,GACb,QAAQ,OAAO;KAAE,MAAM;KAAG,WAAW;IAAmB,CAAC;GAE7D,CAAC;EACH,EACF;CACF;AACF,CAAC"}
+{"version":3,"file":"no_model_in_tool_handler.mjs","names":[],"sources":["../../../src/eslint/rules/no_model_in_tool_handler.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/no_model_in_tool_handler\n *\n * Flags an LLM/model call inside a `Tool` / `ArtifactTool` `handler`.\n *\n * Why: the executor owns the dispatch loop. A tool handler runs as one step the model proposed; it\n * must do work and return a result, not start its own reasoning loop. Calling a model from inside a\n * handler hides a nested, unmanaged dispatch from the harness — no token accounting, no event\n * surfacing, no abort propagation. The one legitimate exception is a tool that is explicitly a\n * sub-agent running its own scoped dispatch; this rule allows a handler that constructs a\n * `new TurnRunner(...)` or calls the lower-level `DispatchRunner.dispatch(...)`.\n *\n * Detects provider SDK constructors (`new OpenAI()`, `new Anthropic()`) and chat/completion calls\n * (a `.create()` whose receiver chain passes through `messages`/`completions`/`responses`, or a\n * `generateContent()` call) within the `handler` function passed to `new Tool({ handler })` /\n * `new ArtifactTool({ handler })`, ignoring inner closures (so a sub-agent's own callbacks don't\n * false-positive).\n *\n * Opt-out:\n *   // eslint-disable-next-line adk/no-model-in-tool-handler -- <reason>\n */\n\nimport {\n  createRule,\n  isFunctionNode,\n  isLlmCall,\n  runsSubAgent,\n  walkBodySkippingNestedFunctions,\n} from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\nconst literalKey = (prop: TSESTree.Property): string | undefined => {\n  if (prop.computed) return undefined\n  if (prop.key.type === 'Identifier') return prop.key.name\n  if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') return prop.key.value\n  return undefined\n}\n\n/** ESLint rule: flags referencing the model or LLM adapter inside a tool handler. */\nconst noModelInToolHandlerRule = createRule({\n  name: 'no-model-in-tool-handler',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        'A Tool/ArtifactTool handler must not invoke a model — the executor owns the dispatch loop. The only exception is a sub-agent tool that runs its own scoped dispatch via `new TurnRunner(...)` or `DispatchRunner.dispatch(...)`.',\n    },\n    schema: [],\n    messages: {\n      noModelInHandler:\n        'Do not call a model inside a tool handler — the executor owns the dispatch loop, and a model call here hides an unmanaged nested dispatch (no token accounting, events, or abort). If this tool is a sub-agent, run a scoped `new TurnRunner(...)` or `DispatchRunner.dispatch(...)` instead. Opt out with an eslint-disable-next-line adk/no-model-in-tool-handler comment + reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      NewExpression(node: TSESTree.NewExpression) {\n        if (\n          node.callee.type !== 'Identifier' ||\n          (node.callee.name !== 'Tool' && node.callee.name !== 'ArtifactTool')\n        ) {\n          return\n        }\n        const arg = node.arguments[0]\n        if (!arg || arg.type !== 'ObjectExpression') return\n\n        const handlerProp = arg.properties.find(\n          (p): p is TSESTree.Property => p.type === 'Property' && literalKey(p) === 'handler'\n        )\n        if (!handlerProp || !isFunctionNode(handlerProp.value)) return\n        const handler = handlerProp.value\n\n        // A sub-agent tool legitimately runs a scoped dispatch (new TurnRunner / DispatchRunner.dispatch)\n        // — that's the documented exception.\n        if (runsSubAgent(handler.body)) return\n\n        walkBodySkippingNestedFunctions(handler.body, (n) => {\n          if (isLlmCall(n)) {\n            context.report({ node: n, messageId: 'noModelInHandler' })\n          }\n        })\n      },\n    }\n  },\n})\n\nexport default noModelInToolHandlerRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAgCA,IAAM,cAAc,SAAgD;CAClE,IAAI,KAAK,UAAU,OAAO,KAAA;CAC1B,IAAI,KAAK,IAAI,SAAS,cAAc,OAAO,KAAK,IAAI;CACpD,IAAI,KAAK,IAAI,SAAS,aAAa,OAAO,KAAK,IAAI,UAAU,UAAU,OAAO,KAAK,IAAI;AAEzF;;AAGA,IAAM,2BAA2B,WAAW;CAC1C,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,mOACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,kBACE,wXACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,cAAc,MAA8B;GAC1C,IACE,KAAK,OAAO,SAAS,gBACpB,KAAK,OAAO,SAAS,UAAU,KAAK,OAAO,SAAS,gBAErD;GAEF,MAAM,MAAM,KAAK,UAAU;GAC3B,IAAI,CAAC,OAAO,IAAI,SAAS,oBAAoB;GAE7C,MAAM,cAAc,IAAI,WAAW,MAChC,MAA8B,EAAE,SAAS,cAAc,WAAW,CAAC,MAAM,SAC5E;GACA,IAAI,CAAC,eAAe,CAAC,eAAe,YAAY,KAAK,GAAG;GACxD,MAAM,UAAU,YAAY;GAI5B,IAAI,aAAa,QAAQ,IAAI,GAAG;GAEhC,gCAAgC,QAAQ,OAAO,MAAM;IACnD,IAAI,UAAU,CAAC,GACb,QAAQ,OAAO;KAAE,MAAM;KAAG,WAAW;IAAmB,CAAC;GAE7D,CAAC;EACH,EACF;CACF;AACF,CAAC"}

package/eslint/rules/require_validator_any_required.cjs

@@ -72,6 +72,7 @@ var collectChainCalls = (anyCall) => {
 	return calls;
 };
 var chainCalls = (calls, name) => calls.some((c) => c.callee.type === "MemberExpression" && c.callee.property.type === "Identifier" && c.callee.property.name === name);
+/** ESLint rule: flags a validator `any()` schema lacking an explicit required/optional/forbidden disposition. */
 var requireValidatorAnyRequiredRule = require_common.createRule({
 	name: "require-validator-any-required",
 	meta: {

package/eslint/rules/require_validator_any_required.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"require_validator_any_required.cjs","names":[],"sources":["../../../src/eslint/rules/require_validator_any_required.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/require_validator_any_required\n *\n * Flags every `validator.any()` schema chain that does not declare intent with `.required()`\n * or `.optional()`.\n *\n * Why: in `@nhtio/validation`, `.any()` ADMITS `null`/`undefined` unless you make it `.required()`.\n * That default is silent and easy to miss — a schema you believe rejects missing values quietly\n * accepts them, and any `.custom()` refinement is skipped for an absent value (a `.custom()` guard\n * is the usual way this surfaces, e.g. `implementsX(undefined) === true`). The fix is to make the\n * disposition an EXPLICIT declaration with no ambiguity — every `.any()` must say which it is:\n *   - `.required()`  → reject null/undefined\n *   - `.optional()`  → deliberately allow null/undefined\n *   - `.default(x)`  → allow absence, substituting a fallback value\n *   - `.forbidden()` → the value must be absent\n * This applies whether the `.any()` is top-level or nested inside `items(...)` / `alternatives(...)`:\n * the enclosing schema being `.required()` does NOT govern an inner `.any()`'s null/undefined handling.\n *\n * The sharpest illustration is `.valid(null)`: an author writing `validator.any().valid(null)`\n * means \"must be exactly null\" — but because `.any()` admits `undefined`, that schema actually\n * accepts BOTH `null` and `undefined` (and `undefined !== null`). The fix is\n * `validator.any().required().valid(null)`.\n *\n * Opt-out (e.g. a bare `.any()` used purely as a type argument like `items(validator.any())`):\n *   // eslint-disable-next-line adk/require-validator-any-required -- <reason>\n */\n\nimport { createRule } from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\n// The base identifier a member/call chain roots at, e.g. `validator` in `validator.any()` or\n// `validator.alternatives(...).any()`. Returns undefined if the chain doesn't root at a plain name.\nconst baseIdentifierName = (node: TSESTree.Node | undefined): string | undefined => {\n  let cur: TSESTree.Node | undefined = node\n  while (cur) {\n    if (cur.type === 'Identifier') return cur.name\n    if (cur.type === 'MemberExpression') {\n      cur = cur.object\n      continue\n    }\n    if (cur.type === 'CallExpression') {\n      cur = cur.callee\n      continue\n    }\n    return undefined\n  }\n  return undefined\n}\n\n// `validator.any()` (or a `validator.…().any()` chain) — NOT `expect.any()`, `_.any()`, etc.\nconst isAnyCall = (node: TSESTree.CallExpression): boolean =>\n  node.callee.type === 'MemberExpression' &&\n  node.callee.property.type === 'Identifier' &&\n  node.callee.property.name === 'any' &&\n  baseIdentifierName(node.callee.object) === 'validator'\n\n// Collect every CallExpression in the method chain `anyCall` belongs to — inward through the\n// callee object (`a.b().c()` -> `a.b()`) and outward through `.parent` links\n// (`x.any()` -> `x.any().required` -> `x.any().required()`).\nconst collectChainCalls = (anyCall: TSESTree.CallExpression): TSESTree.CallExpression[] => {\n  const calls: TSESTree.CallExpression[] = []\n\n  let cur: TSESTree.Node | null = anyCall\n  while (cur && cur.type === 'CallExpression') {\n    calls.push(cur)\n    cur = cur.callee.type === 'MemberExpression' ? cur.callee.object : null\n  }\n\n  cur = anyCall\n  while (cur) {\n    const p: TSESTree.Node | undefined = cur.parent\n    if (!p) break\n    if (p.type === 'MemberExpression' && p.object === cur) {\n      cur = p\n      continue\n    }\n    if (p.type === 'CallExpression' && p.callee === cur) {\n      calls.push(p)\n      cur = p\n      continue\n    }\n    break\n  }\n\n  return calls\n}\n\nconst chainCalls = (calls: TSESTree.CallExpression[], name: string): boolean =>\n  calls.some(\n    (c) =>\n      c.callee.type === 'MemberExpression' &&\n      c.callee.property.type === 'Identifier' &&\n      c.callee.property.name === name\n  )\n\nconst requireValidatorAnyRequiredRule = createRule({\n  name: 'require-validator-any-required',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        '`validator.any()` admits null/undefined unless `.required()`; make the disposition explicit by ending every `.any()` in `.required()`, `.optional()`, or `.default(…)`. Opt out with a tactical disable comment + reason.',\n    },\n    schema: [],\n    messages: {\n      declareIntent:\n        '`validator.any()` admits null/undefined unless made `.required()`. Make the disposition explicit: end this `.any()` in `.required()` (reject null/undefined), `.optional()` (deliberately allow it), or `.default(…)` (allow it with a fallback) — applies even when nested in items()/alternatives(). Or add an eslint-disable-next-line adk/require-validator-any-required comment with a reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      CallExpression(node: TSESTree.CallExpression) {\n        if (!isAnyCall(node)) return\n        const calls = collectChainCalls(node)\n        // An unambiguous disposition declaration clears the rule:\n        //   .required()  — reject null/undefined\n        //   .optional()  — deliberately allow null/undefined\n        //   .default(x)  — allow absence, substituting a fallback\n        //   .forbidden() — the value must be absent\n        if (\n          chainCalls(calls, 'required') ||\n          chainCalls(calls, 'optional') ||\n          chainCalls(calls, 'default') ||\n          chainCalls(calls, 'forbidden')\n        ) {\n          return\n        }\n        const reportNode = node.callee.type === 'MemberExpression' ? node.callee.property : node\n        context.report({ node: reportNode, messageId: 'declareIntent' })\n      },\n    }\n  },\n})\n\nexport default requireValidatorAnyRequiredRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,IAAM,sBAAsB,SAAwD;CAClF,IAAI,MAAiC;CACrC,OAAO,KAAK;EACV,IAAI,IAAI,SAAS,cAAc,OAAO,IAAI;EAC1C,IAAI,IAAI,SAAS,oBAAoB;GACnC,MAAM,IAAI;GACV;EACF;EACA,IAAI,IAAI,SAAS,kBAAkB;GACjC,MAAM,IAAI;GACV;EACF;EACA;CACF;AAEF;AAGA,IAAM,aAAa,SACjB,KAAK,OAAO,SAAS,sBACrB,KAAK,OAAO,SAAS,SAAS,gBAC9B,KAAK,OAAO,SAAS,SAAS,SAC9B,mBAAmB,KAAK,OAAO,MAAM,MAAM;AAK7C,IAAM,qBAAqB,YAAgE;CACzF,MAAM,QAAmC,CAAC;CAE1C,IAAI,MAA4B;CAChC,OAAO,OAAO,IAAI,SAAS,kBAAkB;EAC3C,MAAM,KAAK,GAAG;EACd,MAAM,IAAI,OAAO,SAAS,qBAAqB,IAAI,OAAO,SAAS;CACrE;CAEA,MAAM;CACN,OAAO,KAAK;EACV,MAAM,IAA+B,IAAI;EACzC,IAAI,CAAC,GAAG;EACR,IAAI,EAAE,SAAS,sBAAsB,EAAE,WAAW,KAAK;GACrD,MAAM;GACN;EACF;EACA,IAAI,EAAE,SAAS,oBAAoB,EAAE,WAAW,KAAK;GACnD,MAAM,KAAK,CAAC;GACZ,MAAM;GACN;EACF;EACA;CACF;CAEA,OAAO;AACT;AAEA,IAAM,cAAc,OAAkC,SACpD,MAAM,MACH,MACC,EAAE,OAAO,SAAS,sBAClB,EAAE,OAAO,SAAS,SAAS,gBAC3B,EAAE,OAAO,SAAS,SAAS,IAC/B;AAEF,IAAM,kCAAkC,eAAA,WAAW;CACjD,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,4NACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,eACE,sYACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,eAAe,MAA+B;GAC5C,IAAI,CAAC,UAAU,IAAI,GAAG;GACtB,MAAM,QAAQ,kBAAkB,IAAI;GAMpC,IACE,WAAW,OAAO,UAAU,KAC5B,WAAW,OAAO,UAAU,KAC5B,WAAW,OAAO,SAAS,KAC3B,WAAW,OAAO,WAAW,GAE7B;GAEF,MAAM,aAAa,KAAK,OAAO,SAAS,qBAAqB,KAAK,OAAO,WAAW;GACpF,QAAQ,OAAO;IAAE,MAAM;IAAY,WAAW;GAAgB,CAAC;EACjE,EACF;CACF;AACF,CAAC"}
+{"version":3,"file":"require_validator_any_required.cjs","names":[],"sources":["../../../src/eslint/rules/require_validator_any_required.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/require_validator_any_required\n *\n * Flags every `validator.any()` schema chain that does not declare intent with `.required()`\n * or `.optional()`.\n *\n * Why: in `@nhtio/validation`, `.any()` ADMITS `null`/`undefined` unless you make it `.required()`.\n * That default is silent and easy to miss — a schema you believe rejects missing values quietly\n * accepts them, and any `.custom()` refinement is skipped for an absent value (a `.custom()` guard\n * is the usual way this surfaces, e.g. `implementsX(undefined) === true`). The fix is to make the\n * disposition an EXPLICIT declaration with no ambiguity — every `.any()` must say which it is:\n *   - `.required()`  → reject null/undefined\n *   - `.optional()`  → deliberately allow null/undefined\n *   - `.default(x)`  → allow absence, substituting a fallback value\n *   - `.forbidden()` → the value must be absent\n * This applies whether the `.any()` is top-level or nested inside `items(...)` / `alternatives(...)`:\n * the enclosing schema being `.required()` does NOT govern an inner `.any()`'s null/undefined handling.\n *\n * The sharpest illustration is `.valid(null)`: an author writing `validator.any().valid(null)`\n * means \"must be exactly null\" — but because `.any()` admits `undefined`, that schema actually\n * accepts BOTH `null` and `undefined` (and `undefined !== null`). The fix is\n * `validator.any().required().valid(null)`.\n *\n * Opt-out (e.g. a bare `.any()` used purely as a type argument like `items(validator.any())`):\n *   // eslint-disable-next-line adk/require-validator-any-required -- <reason>\n */\n\nimport { createRule } from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\n// The base identifier a member/call chain roots at, e.g. `validator` in `validator.any()` or\n// `validator.alternatives(...).any()`. Returns undefined if the chain doesn't root at a plain name.\nconst baseIdentifierName = (node: TSESTree.Node | undefined): string | undefined => {\n  let cur: TSESTree.Node | undefined = node\n  while (cur) {\n    if (cur.type === 'Identifier') return cur.name\n    if (cur.type === 'MemberExpression') {\n      cur = cur.object\n      continue\n    }\n    if (cur.type === 'CallExpression') {\n      cur = cur.callee\n      continue\n    }\n    return undefined\n  }\n  return undefined\n}\n\n// `validator.any()` (or a `validator.…().any()` chain) — NOT `expect.any()`, `_.any()`, etc.\nconst isAnyCall = (node: TSESTree.CallExpression): boolean =>\n  node.callee.type === 'MemberExpression' &&\n  node.callee.property.type === 'Identifier' &&\n  node.callee.property.name === 'any' &&\n  baseIdentifierName(node.callee.object) === 'validator'\n\n// Collect every CallExpression in the method chain `anyCall` belongs to — inward through the\n// callee object (`a.b().c()` -> `a.b()`) and outward through `.parent` links\n// (`x.any()` -> `x.any().required` -> `x.any().required()`).\nconst collectChainCalls = (anyCall: TSESTree.CallExpression): TSESTree.CallExpression[] => {\n  const calls: TSESTree.CallExpression[] = []\n\n  let cur: TSESTree.Node | null = anyCall\n  while (cur && cur.type === 'CallExpression') {\n    calls.push(cur)\n    cur = cur.callee.type === 'MemberExpression' ? cur.callee.object : null\n  }\n\n  cur = anyCall\n  while (cur) {\n    const p: TSESTree.Node | undefined = cur.parent\n    if (!p) break\n    if (p.type === 'MemberExpression' && p.object === cur) {\n      cur = p\n      continue\n    }\n    if (p.type === 'CallExpression' && p.callee === cur) {\n      calls.push(p)\n      cur = p\n      continue\n    }\n    break\n  }\n\n  return calls\n}\n\nconst chainCalls = (calls: TSESTree.CallExpression[], name: string): boolean =>\n  calls.some(\n    (c) =>\n      c.callee.type === 'MemberExpression' &&\n      c.callee.property.type === 'Identifier' &&\n      c.callee.property.name === name\n  )\n\n/** ESLint rule: flags a validator `any()` schema lacking an explicit required/optional/forbidden disposition. */\nconst requireValidatorAnyRequiredRule = createRule({\n  name: 'require-validator-any-required',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        '`validator.any()` admits null/undefined unless `.required()`; make the disposition explicit by ending every `.any()` in `.required()`, `.optional()`, or `.default(…)`. Opt out with a tactical disable comment + reason.',\n    },\n    schema: [],\n    messages: {\n      declareIntent:\n        '`validator.any()` admits null/undefined unless made `.required()`. Make the disposition explicit: end this `.any()` in `.required()` (reject null/undefined), `.optional()` (deliberately allow it), or `.default(…)` (allow it with a fallback) — applies even when nested in items()/alternatives(). Or add an eslint-disable-next-line adk/require-validator-any-required comment with a reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      CallExpression(node: TSESTree.CallExpression) {\n        if (!isAnyCall(node)) return\n        const calls = collectChainCalls(node)\n        // An unambiguous disposition declaration clears the rule:\n        //   .required()  — reject null/undefined\n        //   .optional()  — deliberately allow null/undefined\n        //   .default(x)  — allow absence, substituting a fallback\n        //   .forbidden() — the value must be absent\n        if (\n          chainCalls(calls, 'required') ||\n          chainCalls(calls, 'optional') ||\n          chainCalls(calls, 'default') ||\n          chainCalls(calls, 'forbidden')\n        ) {\n          return\n        }\n        const reportNode = node.callee.type === 'MemberExpression' ? node.callee.property : node\n        context.report({ node: reportNode, messageId: 'declareIntent' })\n      },\n    }\n  },\n})\n\nexport default requireValidatorAnyRequiredRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,IAAM,sBAAsB,SAAwD;CAClF,IAAI,MAAiC;CACrC,OAAO,KAAK;EACV,IAAI,IAAI,SAAS,cAAc,OAAO,IAAI;EAC1C,IAAI,IAAI,SAAS,oBAAoB;GACnC,MAAM,IAAI;GACV;EACF;EACA,IAAI,IAAI,SAAS,kBAAkB;GACjC,MAAM,IAAI;GACV;EACF;EACA;CACF;AAEF;AAGA,IAAM,aAAa,SACjB,KAAK,OAAO,SAAS,sBACrB,KAAK,OAAO,SAAS,SAAS,gBAC9B,KAAK,OAAO,SAAS,SAAS,SAC9B,mBAAmB,KAAK,OAAO,MAAM,MAAM;AAK7C,IAAM,qBAAqB,YAAgE;CACzF,MAAM,QAAmC,CAAC;CAE1C,IAAI,MAA4B;CAChC,OAAO,OAAO,IAAI,SAAS,kBAAkB;EAC3C,MAAM,KAAK,GAAG;EACd,MAAM,IAAI,OAAO,SAAS,qBAAqB,IAAI,OAAO,SAAS;CACrE;CAEA,MAAM;CACN,OAAO,KAAK;EACV,MAAM,IAA+B,IAAI;EACzC,IAAI,CAAC,GAAG;EACR,IAAI,EAAE,SAAS,sBAAsB,EAAE,WAAW,KAAK;GACrD,MAAM;GACN;EACF;EACA,IAAI,EAAE,SAAS,oBAAoB,EAAE,WAAW,KAAK;GACnD,MAAM,KAAK,CAAC;GACZ,MAAM;GACN;EACF;EACA;CACF;CAEA,OAAO;AACT;AAEA,IAAM,cAAc,OAAkC,SACpD,MAAM,MACH,MACC,EAAE,OAAO,SAAS,sBAClB,EAAE,OAAO,SAAS,SAAS,gBAC3B,EAAE,OAAO,SAAS,SAAS,IAC/B;;AAGF,IAAM,kCAAkC,eAAA,WAAW;CACjD,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,4NACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,eACE,sYACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,eAAe,MAA+B;GAC5C,IAAI,CAAC,UAAU,IAAI,GAAG;GACtB,MAAM,QAAQ,kBAAkB,IAAI;GAMpC,IACE,WAAW,OAAO,UAAU,KAC5B,WAAW,OAAO,UAAU,KAC5B,WAAW,OAAO,SAAS,KAC3B,WAAW,OAAO,WAAW,GAE7B;GAEF,MAAM,aAAa,KAAK,OAAO,SAAS,qBAAqB,KAAK,OAAO,WAAW;GACpF,QAAQ,OAAO;IAAE,MAAM;IAAY,WAAW;GAAgB,CAAC;EACjE,EACF;CACF;AACF,CAAC"}

package/eslint/rules/require_validator_any_required.d.ts

@@ -24,6 +24,7 @@
  * Opt-out (e.g. a bare `.any()` used purely as a type argument like `items(validator.any())`):
  *   // eslint-disable-next-line adk/require-validator-any-required -- <reason>
  */
+/** ESLint rule: flags a validator `any()` schema lacking an explicit required/optional/forbidden disposition. */
 declare const requireValidatorAnyRequiredRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"declareIntent", [
 ], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;

package/eslint/rules/require_validator_any_required.mjs

@@ -67,6 +67,7 @@ var collectChainCalls = (anyCall) => {
 	return calls;
 };
 var chainCalls = (calls, name) => calls.some((c) => c.callee.type === "MemberExpression" && c.callee.property.type === "Identifier" && c.callee.property.name === name);
+/** ESLint rule: flags a validator `any()` schema lacking an explicit required/optional/forbidden disposition. */
 var requireValidatorAnyRequiredRule = createRule({
 	name: "require-validator-any-required",
 	meta: {

package/eslint/rules/require_validator_any_required.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"require_validator_any_required.mjs","names":[],"sources":["../../../src/eslint/rules/require_validator_any_required.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/require_validator_any_required\n *\n * Flags every `validator.any()` schema chain that does not declare intent with `.required()`\n * or `.optional()`.\n *\n * Why: in `@nhtio/validation`, `.any()` ADMITS `null`/`undefined` unless you make it `.required()`.\n * That default is silent and easy to miss — a schema you believe rejects missing values quietly\n * accepts them, and any `.custom()` refinement is skipped for an absent value (a `.custom()` guard\n * is the usual way this surfaces, e.g. `implementsX(undefined) === true`). The fix is to make the\n * disposition an EXPLICIT declaration with no ambiguity — every `.any()` must say which it is:\n *   - `.required()`  → reject null/undefined\n *   - `.optional()`  → deliberately allow null/undefined\n *   - `.default(x)`  → allow absence, substituting a fallback value\n *   - `.forbidden()` → the value must be absent\n * This applies whether the `.any()` is top-level or nested inside `items(...)` / `alternatives(...)`:\n * the enclosing schema being `.required()` does NOT govern an inner `.any()`'s null/undefined handling.\n *\n * The sharpest illustration is `.valid(null)`: an author writing `validator.any().valid(null)`\n * means \"must be exactly null\" — but because `.any()` admits `undefined`, that schema actually\n * accepts BOTH `null` and `undefined` (and `undefined !== null`). The fix is\n * `validator.any().required().valid(null)`.\n *\n * Opt-out (e.g. a bare `.any()` used purely as a type argument like `items(validator.any())`):\n *   // eslint-disable-next-line adk/require-validator-any-required -- <reason>\n */\n\nimport { createRule } from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\n// The base identifier a member/call chain roots at, e.g. `validator` in `validator.any()` or\n// `validator.alternatives(...).any()`. Returns undefined if the chain doesn't root at a plain name.\nconst baseIdentifierName = (node: TSESTree.Node | undefined): string | undefined => {\n  let cur: TSESTree.Node | undefined = node\n  while (cur) {\n    if (cur.type === 'Identifier') return cur.name\n    if (cur.type === 'MemberExpression') {\n      cur = cur.object\n      continue\n    }\n    if (cur.type === 'CallExpression') {\n      cur = cur.callee\n      continue\n    }\n    return undefined\n  }\n  return undefined\n}\n\n// `validator.any()` (or a `validator.…().any()` chain) — NOT `expect.any()`, `_.any()`, etc.\nconst isAnyCall = (node: TSESTree.CallExpression): boolean =>\n  node.callee.type === 'MemberExpression' &&\n  node.callee.property.type === 'Identifier' &&\n  node.callee.property.name === 'any' &&\n  baseIdentifierName(node.callee.object) === 'validator'\n\n// Collect every CallExpression in the method chain `anyCall` belongs to — inward through the\n// callee object (`a.b().c()` -> `a.b()`) and outward through `.parent` links\n// (`x.any()` -> `x.any().required` -> `x.any().required()`).\nconst collectChainCalls = (anyCall: TSESTree.CallExpression): TSESTree.CallExpression[] => {\n  const calls: TSESTree.CallExpression[] = []\n\n  let cur: TSESTree.Node | null = anyCall\n  while (cur && cur.type === 'CallExpression') {\n    calls.push(cur)\n    cur = cur.callee.type === 'MemberExpression' ? cur.callee.object : null\n  }\n\n  cur = anyCall\n  while (cur) {\n    const p: TSESTree.Node | undefined = cur.parent\n    if (!p) break\n    if (p.type === 'MemberExpression' && p.object === cur) {\n      cur = p\n      continue\n    }\n    if (p.type === 'CallExpression' && p.callee === cur) {\n      calls.push(p)\n      cur = p\n      continue\n    }\n    break\n  }\n\n  return calls\n}\n\nconst chainCalls = (calls: TSESTree.CallExpression[], name: string): boolean =>\n  calls.some(\n    (c) =>\n      c.callee.type === 'MemberExpression' &&\n      c.callee.property.type === 'Identifier' &&\n      c.callee.property.name === name\n  )\n\nconst requireValidatorAnyRequiredRule = createRule({\n  name: 'require-validator-any-required',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        '`validator.any()` admits null/undefined unless `.required()`; make the disposition explicit by ending every `.any()` in `.required()`, `.optional()`, or `.default(…)`. Opt out with a tactical disable comment + reason.',\n    },\n    schema: [],\n    messages: {\n      declareIntent:\n        '`validator.any()` admits null/undefined unless made `.required()`. Make the disposition explicit: end this `.any()` in `.required()` (reject null/undefined), `.optional()` (deliberately allow it), or `.default(…)` (allow it with a fallback) — applies even when nested in items()/alternatives(). Or add an eslint-disable-next-line adk/require-validator-any-required comment with a reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      CallExpression(node: TSESTree.CallExpression) {\n        if (!isAnyCall(node)) return\n        const calls = collectChainCalls(node)\n        // An unambiguous disposition declaration clears the rule:\n        //   .required()  — reject null/undefined\n        //   .optional()  — deliberately allow null/undefined\n        //   .default(x)  — allow absence, substituting a fallback\n        //   .forbidden() — the value must be absent\n        if (\n          chainCalls(calls, 'required') ||\n          chainCalls(calls, 'optional') ||\n          chainCalls(calls, 'default') ||\n          chainCalls(calls, 'forbidden')\n        ) {\n          return\n        }\n        const reportNode = node.callee.type === 'MemberExpression' ? node.callee.property : node\n        context.report({ node: reportNode, messageId: 'declareIntent' })\n      },\n    }\n  },\n})\n\nexport default requireValidatorAnyRequiredRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,IAAM,sBAAsB,SAAwD;CAClF,IAAI,MAAiC;CACrC,OAAO,KAAK;EACV,IAAI,IAAI,SAAS,cAAc,OAAO,IAAI;EAC1C,IAAI,IAAI,SAAS,oBAAoB;GACnC,MAAM,IAAI;GACV;EACF;EACA,IAAI,IAAI,SAAS,kBAAkB;GACjC,MAAM,IAAI;GACV;EACF;EACA;CACF;AAEF;AAGA,IAAM,aAAa,SACjB,KAAK,OAAO,SAAS,sBACrB,KAAK,OAAO,SAAS,SAAS,gBAC9B,KAAK,OAAO,SAAS,SAAS,SAC9B,mBAAmB,KAAK,OAAO,MAAM,MAAM;AAK7C,IAAM,qBAAqB,YAAgE;CACzF,MAAM,QAAmC,CAAC;CAE1C,IAAI,MAA4B;CAChC,OAAO,OAAO,IAAI,SAAS,kBAAkB;EAC3C,MAAM,KAAK,GAAG;EACd,MAAM,IAAI,OAAO,SAAS,qBAAqB,IAAI,OAAO,SAAS;CACrE;CAEA,MAAM;CACN,OAAO,KAAK;EACV,MAAM,IAA+B,IAAI;EACzC,IAAI,CAAC,GAAG;EACR,IAAI,EAAE,SAAS,sBAAsB,EAAE,WAAW,KAAK;GACrD,MAAM;GACN;EACF;EACA,IAAI,EAAE,SAAS,oBAAoB,EAAE,WAAW,KAAK;GACnD,MAAM,KAAK,CAAC;GACZ,MAAM;GACN;EACF;EACA;CACF;CAEA,OAAO;AACT;AAEA,IAAM,cAAc,OAAkC,SACpD,MAAM,MACH,MACC,EAAE,OAAO,SAAS,sBAClB,EAAE,OAAO,SAAS,SAAS,gBAC3B,EAAE,OAAO,SAAS,SAAS,IAC/B;AAEF,IAAM,kCAAkC,WAAW;CACjD,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,4NACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,eACE,sYACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,eAAe,MAA+B;GAC5C,IAAI,CAAC,UAAU,IAAI,GAAG;GACtB,MAAM,QAAQ,kBAAkB,IAAI;GAMpC,IACE,WAAW,OAAO,UAAU,KAC5B,WAAW,OAAO,UAAU,KAC5B,WAAW,OAAO,SAAS,KAC3B,WAAW,OAAO,WAAW,GAE7B;GAEF,MAAM,aAAa,KAAK,OAAO,SAAS,qBAAqB,KAAK,OAAO,WAAW;GACpF,QAAQ,OAAO;IAAE,MAAM;IAAY,WAAW;GAAgB,CAAC;EACjE,EACF;CACF;AACF,CAAC"}
+{"version":3,"file":"require_validator_any_required.mjs","names":[],"sources":["../../../src/eslint/rules/require_validator_any_required.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/require_validator_any_required\n *\n * Flags every `validator.any()` schema chain that does not declare intent with `.required()`\n * or `.optional()`.\n *\n * Why: in `@nhtio/validation`, `.any()` ADMITS `null`/`undefined` unless you make it `.required()`.\n * That default is silent and easy to miss — a schema you believe rejects missing values quietly\n * accepts them, and any `.custom()` refinement is skipped for an absent value (a `.custom()` guard\n * is the usual way this surfaces, e.g. `implementsX(undefined) === true`). The fix is to make the\n * disposition an EXPLICIT declaration with no ambiguity — every `.any()` must say which it is:\n *   - `.required()`  → reject null/undefined\n *   - `.optional()`  → deliberately allow null/undefined\n *   - `.default(x)`  → allow absence, substituting a fallback value\n *   - `.forbidden()` → the value must be absent\n * This applies whether the `.any()` is top-level or nested inside `items(...)` / `alternatives(...)`:\n * the enclosing schema being `.required()` does NOT govern an inner `.any()`'s null/undefined handling.\n *\n * The sharpest illustration is `.valid(null)`: an author writing `validator.any().valid(null)`\n * means \"must be exactly null\" — but because `.any()` admits `undefined`, that schema actually\n * accepts BOTH `null` and `undefined` (and `undefined !== null`). The fix is\n * `validator.any().required().valid(null)`.\n *\n * Opt-out (e.g. a bare `.any()` used purely as a type argument like `items(validator.any())`):\n *   // eslint-disable-next-line adk/require-validator-any-required -- <reason>\n */\n\nimport { createRule } from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\n// The base identifier a member/call chain roots at, e.g. `validator` in `validator.any()` or\n// `validator.alternatives(...).any()`. Returns undefined if the chain doesn't root at a plain name.\nconst baseIdentifierName = (node: TSESTree.Node | undefined): string | undefined => {\n  let cur: TSESTree.Node | undefined = node\n  while (cur) {\n    if (cur.type === 'Identifier') return cur.name\n    if (cur.type === 'MemberExpression') {\n      cur = cur.object\n      continue\n    }\n    if (cur.type === 'CallExpression') {\n      cur = cur.callee\n      continue\n    }\n    return undefined\n  }\n  return undefined\n}\n\n// `validator.any()` (or a `validator.…().any()` chain) — NOT `expect.any()`, `_.any()`, etc.\nconst isAnyCall = (node: TSESTree.CallExpression): boolean =>\n  node.callee.type === 'MemberExpression' &&\n  node.callee.property.type === 'Identifier' &&\n  node.callee.property.name === 'any' &&\n  baseIdentifierName(node.callee.object) === 'validator'\n\n// Collect every CallExpression in the method chain `anyCall` belongs to — inward through the\n// callee object (`a.b().c()` -> `a.b()`) and outward through `.parent` links\n// (`x.any()` -> `x.any().required` -> `x.any().required()`).\nconst collectChainCalls = (anyCall: TSESTree.CallExpression): TSESTree.CallExpression[] => {\n  const calls: TSESTree.CallExpression[] = []\n\n  let cur: TSESTree.Node | null = anyCall\n  while (cur && cur.type === 'CallExpression') {\n    calls.push(cur)\n    cur = cur.callee.type === 'MemberExpression' ? cur.callee.object : null\n  }\n\n  cur = anyCall\n  while (cur) {\n    const p: TSESTree.Node | undefined = cur.parent\n    if (!p) break\n    if (p.type === 'MemberExpression' && p.object === cur) {\n      cur = p\n      continue\n    }\n    if (p.type === 'CallExpression' && p.callee === cur) {\n      calls.push(p)\n      cur = p\n      continue\n    }\n    break\n  }\n\n  return calls\n}\n\nconst chainCalls = (calls: TSESTree.CallExpression[], name: string): boolean =>\n  calls.some(\n    (c) =>\n      c.callee.type === 'MemberExpression' &&\n      c.callee.property.type === 'Identifier' &&\n      c.callee.property.name === name\n  )\n\n/** ESLint rule: flags a validator `any()` schema lacking an explicit required/optional/forbidden disposition. */\nconst requireValidatorAnyRequiredRule = createRule({\n  name: 'require-validator-any-required',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        '`validator.any()` admits null/undefined unless `.required()`; make the disposition explicit by ending every `.any()` in `.required()`, `.optional()`, or `.default(…)`. Opt out with a tactical disable comment + reason.',\n    },\n    schema: [],\n    messages: {\n      declareIntent:\n        '`validator.any()` admits null/undefined unless made `.required()`. Make the disposition explicit: end this `.any()` in `.required()` (reject null/undefined), `.optional()` (deliberately allow it), or `.default(…)` (allow it with a fallback) — applies even when nested in items()/alternatives(). Or add an eslint-disable-next-line adk/require-validator-any-required comment with a reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      CallExpression(node: TSESTree.CallExpression) {\n        if (!isAnyCall(node)) return\n        const calls = collectChainCalls(node)\n        // An unambiguous disposition declaration clears the rule:\n        //   .required()  — reject null/undefined\n        //   .optional()  — deliberately allow null/undefined\n        //   .default(x)  — allow absence, substituting a fallback\n        //   .forbidden() — the value must be absent\n        if (\n          chainCalls(calls, 'required') ||\n          chainCalls(calls, 'optional') ||\n          chainCalls(calls, 'default') ||\n          chainCalls(calls, 'forbidden')\n        ) {\n          return\n        }\n        const reportNode = node.callee.type === 'MemberExpression' ? node.callee.property : node\n        context.report({ node: reportNode, messageId: 'declareIntent' })\n      },\n    }\n  },\n})\n\nexport default requireValidatorAnyRequiredRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,IAAM,sBAAsB,SAAwD;CAClF,IAAI,MAAiC;CACrC,OAAO,KAAK;EACV,IAAI,IAAI,SAAS,cAAc,OAAO,IAAI;EAC1C,IAAI,IAAI,SAAS,oBAAoB;GACnC,MAAM,IAAI;GACV;EACF;EACA,IAAI,IAAI,SAAS,kBAAkB;GACjC,MAAM,IAAI;GACV;EACF;EACA;CACF;AAEF;AAGA,IAAM,aAAa,SACjB,KAAK,OAAO,SAAS,sBACrB,KAAK,OAAO,SAAS,SAAS,gBAC9B,KAAK,OAAO,SAAS,SAAS,SAC9B,mBAAmB,KAAK,OAAO,MAAM,MAAM;AAK7C,IAAM,qBAAqB,YAAgE;CACzF,MAAM,QAAmC,CAAC;CAE1C,IAAI,MAA4B;CAChC,OAAO,OAAO,IAAI,SAAS,kBAAkB;EAC3C,MAAM,KAAK,GAAG;EACd,MAAM,IAAI,OAAO,SAAS,qBAAqB,IAAI,OAAO,SAAS;CACrE;CAEA,MAAM;CACN,OAAO,KAAK;EACV,MAAM,IAA+B,IAAI;EACzC,IAAI,CAAC,GAAG;EACR,IAAI,EAAE,SAAS,sBAAsB,EAAE,WAAW,KAAK;GACrD,MAAM;GACN;EACF;EACA,IAAI,EAAE,SAAS,oBAAoB,EAAE,WAAW,KAAK;GACnD,MAAM,KAAK,CAAC;GACZ,MAAM;GACN;EACF;EACA;CACF;CAEA,OAAO;AACT;AAEA,IAAM,cAAc,OAAkC,SACpD,MAAM,MACH,MACC,EAAE,OAAO,SAAS,sBAClB,EAAE,OAAO,SAAS,SAAS,gBAC3B,EAAE,OAAO,SAAS,SAAS,IAC/B;;AAGF,IAAM,kCAAkC,WAAW;CACjD,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,4NACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,eACE,sYACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,eAAe,MAA+B;GAC5C,IAAI,CAAC,UAAU,IAAI,GAAG;GACtB,MAAM,QAAQ,kBAAkB,IAAI;GAMpC,IACE,WAAW,OAAO,UAAU,KAC5B,WAAW,OAAO,UAAU,KAC5B,WAAW,OAAO,SAAS,KAC3B,WAAW,OAAO,WAAW,GAE7B;GAEF,MAAM,aAAa,KAAK,OAAO,SAAS,qBAAqB,KAAK,OAAO,WAAW;GACpF,QAAQ,OAAO;IAAE,MAAM;IAAY,WAAW;GAAgB,CAAC;EACjE,EACF;CACF;AACF,CAAC"}

package/eslint/rules/thought_payload_requires_replay_tag.cjs

@@ -32,6 +32,7 @@ var literalKey = (prop) => {
 	if (prop.key.type === "Literal" && typeof prop.key.value === "string") return prop.key.value;
 };
 var isUndefinedValue = (node) => node.type === "Identifier" && node.name === "undefined";
+/** ESLint rule: flags a Thought constructed with a payload but no replayCompatibility tag. */
 var thoughtPayloadRequiresReplayTagRule = require_common.createRule({
 	name: "thought-payload-requires-replay-tag",
 	meta: {

package/eslint/rules/thought_payload_requires_replay_tag.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"thought_payload_requires_replay_tag.cjs","names":[],"sources":["../../../src/eslint/rules/thought_payload_requires_replay_tag.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/thought_payload_requires_replay_tag\n *\n * Flags `new Thought({ … })` whose options literal sets a `payload` but omits a\n * `replayCompatibility` tag.\n *\n * Why: a `Thought` may carry a vendor-opaque `payload` that the harness cannot interpret, to be\n * replayed back to a matching model wire. The ADK can only route that payload if the thought also\n * declares which adapter wire-shape it is replayable into, via `replayCompatibility`. A `payload`\n * with no `replayCompatibility` is a footgun: the harness has no way to know which adapter can\n * consume it, so it is dropped silently. The `Thought` constructor enforces this cross-field\n * invariant at runtime (`payload` present ⇒ `replayCompatibility` required); this rule surfaces it\n * statically at the construction site so it fails lint, not just at runtime.\n *\n * Detects the common literal form: a `new Thought({ … })` options object that has a `payload`\n * property but no `replayCompatibility` property. Spreads or computed keys are not analyzable here —\n * those fall back to the runtime check.\n *\n * Opt-out:\n *   // eslint-disable-next-line adk/thought-payload-requires-replay-tag -- <reason>\n */\n\nimport { createRule } from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\nconst literalKey = (prop: TSESTree.Property): string | undefined => {\n  if (prop.computed) return undefined\n  if (prop.key.type === 'Identifier') return prop.key.name\n  if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') return prop.key.value\n  return undefined\n}\n\n// True when the property value is statically `undefined` (the absent case) — `payload: undefined`\n// is equivalent to omitting it, so it should not trigger the rule.\nconst isUndefinedValue = (node: TSESTree.Node): boolean =>\n  node.type === 'Identifier' && node.name === 'undefined'\n\nconst thoughtPayloadRequiresReplayTagRule = createRule({\n  name: 'thought-payload-requires-replay-tag',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        'A `Thought` carrying a `payload` must declare `replayCompatibility`; otherwise the harness cannot route the opaque payload to a matching adapter and drops it. Enforced at runtime by the Thought constructor; this surfaces it at the construction site.',\n    },\n    schema: [],\n    messages: {\n      requireReplayTag:\n        '`new Thought({ payload })` requires a `replayCompatibility` tag — without it the harness cannot route the opaque payload to an adapter and silently drops it. Add `replayCompatibility: \"<wire-shape-id>\"`, or remove the payload. Opt out with an eslint-disable-next-line adk/thought-payload-requires-replay-tag comment + reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      NewExpression(node: TSESTree.NewExpression) {\n        if (node.callee.type !== 'Identifier' || node.callee.name !== 'Thought') return\n        const arg = node.arguments[0]\n        if (!arg || arg.type !== 'ObjectExpression') return\n\n        let payloadProp: TSESTree.Property | undefined\n        let hasReplayTag = false\n        let hasSpread = false\n        for (const p of arg.properties) {\n          if (p.type === 'SpreadElement') {\n            hasSpread = true\n            continue\n          }\n          const key = literalKey(p)\n          if (key === 'payload' && !isUndefinedValue(p.value)) payloadProp = p\n          else if (key === 'replayCompatibility' && !isUndefinedValue(p.value)) hasReplayTag = true\n        }\n\n        // A spread could supply replayCompatibility we can't see — stay conservative, don't flag.\n        if (payloadProp && !hasReplayTag && !hasSpread) {\n          context.report({ node: payloadProp, messageId: 'requireReplayTag' })\n        }\n      },\n    }\n  },\n})\n\nexport default thoughtPayloadRequiresReplayTagRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,IAAM,cAAc,SAAgD;CAClE,IAAI,KAAK,UAAU,OAAO,KAAA;CAC1B,IAAI,KAAK,IAAI,SAAS,cAAc,OAAO,KAAK,IAAI;CACpD,IAAI,KAAK,IAAI,SAAS,aAAa,OAAO,KAAK,IAAI,UAAU,UAAU,OAAO,KAAK,IAAI;AAEzF;AAIA,IAAM,oBAAoB,SACxB,KAAK,SAAS,gBAAgB,KAAK,SAAS;AAE9C,IAAM,sCAAsC,eAAA,WAAW;CACrD,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,4PACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,kBACE,0UACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,cAAc,MAA8B;GAC1C,IAAI,KAAK,OAAO,SAAS,gBAAgB,KAAK,OAAO,SAAS,WAAW;GACzE,MAAM,MAAM,KAAK,UAAU;GAC3B,IAAI,CAAC,OAAO,IAAI,SAAS,oBAAoB;GAE7C,IAAI;GACJ,IAAI,eAAe;GACnB,IAAI,YAAY;GAChB,KAAK,MAAM,KAAK,IAAI,YAAY;IAC9B,IAAI,EAAE,SAAS,iBAAiB;KAC9B,YAAY;KACZ;IACF;IACA,MAAM,MAAM,WAAW,CAAC;IACxB,IAAI,QAAQ,aAAa,CAAC,iBAAiB,EAAE,KAAK,GAAG,cAAc;SAC9D,IAAI,QAAQ,yBAAyB,CAAC,iBAAiB,EAAE,KAAK,GAAG,eAAe;GACvF;GAGA,IAAI,eAAe,CAAC,gBAAgB,CAAC,WACnC,QAAQ,OAAO;IAAE,MAAM;IAAa,WAAW;GAAmB,CAAC;EAEvE,EACF;CACF;AACF,CAAC"}
+{"version":3,"file":"thought_payload_requires_replay_tag.cjs","names":[],"sources":["../../../src/eslint/rules/thought_payload_requires_replay_tag.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/thought_payload_requires_replay_tag\n *\n * Flags `new Thought({ … })` whose options literal sets a `payload` but omits a\n * `replayCompatibility` tag.\n *\n * Why: a `Thought` may carry a vendor-opaque `payload` that the harness cannot interpret, to be\n * replayed back to a matching model wire. The ADK can only route that payload if the thought also\n * declares which adapter wire-shape it is replayable into, via `replayCompatibility`. A `payload`\n * with no `replayCompatibility` is a footgun: the harness has no way to know which adapter can\n * consume it, so it is dropped silently. The `Thought` constructor enforces this cross-field\n * invariant at runtime (`payload` present ⇒ `replayCompatibility` required); this rule surfaces it\n * statically at the construction site so it fails lint, not just at runtime.\n *\n * Detects the common literal form: a `new Thought({ … })` options object that has a `payload`\n * property but no `replayCompatibility` property. Spreads or computed keys are not analyzable here —\n * those fall back to the runtime check.\n *\n * Opt-out:\n *   // eslint-disable-next-line adk/thought-payload-requires-replay-tag -- <reason>\n */\n\nimport { createRule } from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\nconst literalKey = (prop: TSESTree.Property): string | undefined => {\n  if (prop.computed) return undefined\n  if (prop.key.type === 'Identifier') return prop.key.name\n  if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') return prop.key.value\n  return undefined\n}\n\n// True when the property value is statically `undefined` (the absent case) — `payload: undefined`\n// is equivalent to omitting it, so it should not trigger the rule.\nconst isUndefinedValue = (node: TSESTree.Node): boolean =>\n  node.type === 'Identifier' && node.name === 'undefined'\n\n/** ESLint rule: flags a Thought constructed with a payload but no replayCompatibility tag. */\nconst thoughtPayloadRequiresReplayTagRule = createRule({\n  name: 'thought-payload-requires-replay-tag',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        'A `Thought` carrying a `payload` must declare `replayCompatibility`; otherwise the harness cannot route the opaque payload to a matching adapter and drops it. Enforced at runtime by the Thought constructor; this surfaces it at the construction site.',\n    },\n    schema: [],\n    messages: {\n      requireReplayTag:\n        '`new Thought({ payload })` requires a `replayCompatibility` tag — without it the harness cannot route the opaque payload to an adapter and silently drops it. Add `replayCompatibility: \"<wire-shape-id>\"`, or remove the payload. Opt out with an eslint-disable-next-line adk/thought-payload-requires-replay-tag comment + reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      NewExpression(node: TSESTree.NewExpression) {\n        if (node.callee.type !== 'Identifier' || node.callee.name !== 'Thought') return\n        const arg = node.arguments[0]\n        if (!arg || arg.type !== 'ObjectExpression') return\n\n        let payloadProp: TSESTree.Property | undefined\n        let hasReplayTag = false\n        let hasSpread = false\n        for (const p of arg.properties) {\n          if (p.type === 'SpreadElement') {\n            hasSpread = true\n            continue\n          }\n          const key = literalKey(p)\n          if (key === 'payload' && !isUndefinedValue(p.value)) payloadProp = p\n          else if (key === 'replayCompatibility' && !isUndefinedValue(p.value)) hasReplayTag = true\n        }\n\n        // A spread could supply replayCompatibility we can't see — stay conservative, don't flag.\n        if (payloadProp && !hasReplayTag && !hasSpread) {\n          context.report({ node: payloadProp, messageId: 'requireReplayTag' })\n        }\n      },\n    }\n  },\n})\n\nexport default thoughtPayloadRequiresReplayTagRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,IAAM,cAAc,SAAgD;CAClE,IAAI,KAAK,UAAU,OAAO,KAAA;CAC1B,IAAI,KAAK,IAAI,SAAS,cAAc,OAAO,KAAK,IAAI;CACpD,IAAI,KAAK,IAAI,SAAS,aAAa,OAAO,KAAK,IAAI,UAAU,UAAU,OAAO,KAAK,IAAI;AAEzF;AAIA,IAAM,oBAAoB,SACxB,KAAK,SAAS,gBAAgB,KAAK,SAAS;;AAG9C,IAAM,sCAAsC,eAAA,WAAW;CACrD,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,4PACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,kBACE,0UACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,cAAc,MAA8B;GAC1C,IAAI,KAAK,OAAO,SAAS,gBAAgB,KAAK,OAAO,SAAS,WAAW;GACzE,MAAM,MAAM,KAAK,UAAU;GAC3B,IAAI,CAAC,OAAO,IAAI,SAAS,oBAAoB;GAE7C,IAAI;GACJ,IAAI,eAAe;GACnB,IAAI,YAAY;GAChB,KAAK,MAAM,KAAK,IAAI,YAAY;IAC9B,IAAI,EAAE,SAAS,iBAAiB;KAC9B,YAAY;KACZ;IACF;IACA,MAAM,MAAM,WAAW,CAAC;IACxB,IAAI,QAAQ,aAAa,CAAC,iBAAiB,EAAE,KAAK,GAAG,cAAc;SAC9D,IAAI,QAAQ,yBAAyB,CAAC,iBAAiB,EAAE,KAAK,GAAG,eAAe;GACvF;GAGA,IAAI,eAAe,CAAC,gBAAgB,CAAC,WACnC,QAAQ,OAAO;IAAE,MAAM;IAAa,WAAW;GAAmB,CAAC;EAEvE,EACF;CACF;AACF,CAAC"}

package/eslint/rules/thought_payload_requires_replay_tag.d.ts

@@ -19,6 +19,7 @@
  * Opt-out:
  *   // eslint-disable-next-line adk/thought-payload-requires-replay-tag -- <reason>
  */
+/** ESLint rule: flags a Thought constructed with a payload but no replayCompatibility tag. */
 declare const thoughtPayloadRequiresReplayTagRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"requireReplayTag", [
 ], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;

package/eslint/rules/thought_payload_requires_replay_tag.mjs

@@ -27,6 +27,7 @@ var literalKey = (prop) => {
 	if (prop.key.type === "Literal" && typeof prop.key.value === "string") return prop.key.value;
 };
 var isUndefinedValue = (node) => node.type === "Identifier" && node.name === "undefined";
+/** ESLint rule: flags a Thought constructed with a payload but no replayCompatibility tag. */
 var thoughtPayloadRequiresReplayTagRule = createRule({
 	name: "thought-payload-requires-replay-tag",
 	meta: {

package/eslint/rules/thought_payload_requires_replay_tag.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"thought_payload_requires_replay_tag.mjs","names":[],"sources":["../../../src/eslint/rules/thought_payload_requires_replay_tag.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/thought_payload_requires_replay_tag\n *\n * Flags `new Thought({ … })` whose options literal sets a `payload` but omits a\n * `replayCompatibility` tag.\n *\n * Why: a `Thought` may carry a vendor-opaque `payload` that the harness cannot interpret, to be\n * replayed back to a matching model wire. The ADK can only route that payload if the thought also\n * declares which adapter wire-shape it is replayable into, via `replayCompatibility`. A `payload`\n * with no `replayCompatibility` is a footgun: the harness has no way to know which adapter can\n * consume it, so it is dropped silently. The `Thought` constructor enforces this cross-field\n * invariant at runtime (`payload` present ⇒ `replayCompatibility` required); this rule surfaces it\n * statically at the construction site so it fails lint, not just at runtime.\n *\n * Detects the common literal form: a `new Thought({ … })` options object that has a `payload`\n * property but no `replayCompatibility` property. Spreads or computed keys are not analyzable here —\n * those fall back to the runtime check.\n *\n * Opt-out:\n *   // eslint-disable-next-line adk/thought-payload-requires-replay-tag -- <reason>\n */\n\nimport { createRule } from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\nconst literalKey = (prop: TSESTree.Property): string | undefined => {\n  if (prop.computed) return undefined\n  if (prop.key.type === 'Identifier') return prop.key.name\n  if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') return prop.key.value\n  return undefined\n}\n\n// True when the property value is statically `undefined` (the absent case) — `payload: undefined`\n// is equivalent to omitting it, so it should not trigger the rule.\nconst isUndefinedValue = (node: TSESTree.Node): boolean =>\n  node.type === 'Identifier' && node.name === 'undefined'\n\nconst thoughtPayloadRequiresReplayTagRule = createRule({\n  name: 'thought-payload-requires-replay-tag',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        'A `Thought` carrying a `payload` must declare `replayCompatibility`; otherwise the harness cannot route the opaque payload to a matching adapter and drops it. Enforced at runtime by the Thought constructor; this surfaces it at the construction site.',\n    },\n    schema: [],\n    messages: {\n      requireReplayTag:\n        '`new Thought({ payload })` requires a `replayCompatibility` tag — without it the harness cannot route the opaque payload to an adapter and silently drops it. Add `replayCompatibility: \"<wire-shape-id>\"`, or remove the payload. Opt out with an eslint-disable-next-line adk/thought-payload-requires-replay-tag comment + reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      NewExpression(node: TSESTree.NewExpression) {\n        if (node.callee.type !== 'Identifier' || node.callee.name !== 'Thought') return\n        const arg = node.arguments[0]\n        if (!arg || arg.type !== 'ObjectExpression') return\n\n        let payloadProp: TSESTree.Property | undefined\n        let hasReplayTag = false\n        let hasSpread = false\n        for (const p of arg.properties) {\n          if (p.type === 'SpreadElement') {\n            hasSpread = true\n            continue\n          }\n          const key = literalKey(p)\n          if (key === 'payload' && !isUndefinedValue(p.value)) payloadProp = p\n          else if (key === 'replayCompatibility' && !isUndefinedValue(p.value)) hasReplayTag = true\n        }\n\n        // A spread could supply replayCompatibility we can't see — stay conservative, don't flag.\n        if (payloadProp && !hasReplayTag && !hasSpread) {\n          context.report({ node: payloadProp, messageId: 'requireReplayTag' })\n        }\n      },\n    }\n  },\n})\n\nexport default thoughtPayloadRequiresReplayTagRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA0BA,IAAM,cAAc,SAAgD;CAClE,IAAI,KAAK,UAAU,OAAO,KAAA;CAC1B,IAAI,KAAK,IAAI,SAAS,cAAc,OAAO,KAAK,IAAI;CACpD,IAAI,KAAK,IAAI,SAAS,aAAa,OAAO,KAAK,IAAI,UAAU,UAAU,OAAO,KAAK,IAAI;AAEzF;AAIA,IAAM,oBAAoB,SACxB,KAAK,SAAS,gBAAgB,KAAK,SAAS;AAE9C,IAAM,sCAAsC,WAAW;CACrD,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,4PACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,kBACE,0UACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,cAAc,MAA8B;GAC1C,IAAI,KAAK,OAAO,SAAS,gBAAgB,KAAK,OAAO,SAAS,WAAW;GACzE,MAAM,MAAM,KAAK,UAAU;GAC3B,IAAI,CAAC,OAAO,IAAI,SAAS,oBAAoB;GAE7C,IAAI;GACJ,IAAI,eAAe;GACnB,IAAI,YAAY;GAChB,KAAK,MAAM,KAAK,IAAI,YAAY;IAC9B,IAAI,EAAE,SAAS,iBAAiB;KAC9B,YAAY;KACZ;IACF;IACA,MAAM,MAAM,WAAW,CAAC;IACxB,IAAI,QAAQ,aAAa,CAAC,iBAAiB,EAAE,KAAK,GAAG,cAAc;SAC9D,IAAI,QAAQ,yBAAyB,CAAC,iBAAiB,EAAE,KAAK,GAAG,eAAe;GACvF;GAGA,IAAI,eAAe,CAAC,gBAAgB,CAAC,WACnC,QAAQ,OAAO;IAAE,MAAM;IAAa,WAAW;GAAmB,CAAC;EAEvE,EACF;CACF;AACF,CAAC"}
+{"version":3,"file":"thought_payload_requires_replay_tag.mjs","names":[],"sources":["../../../src/eslint/rules/thought_payload_requires_replay_tag.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/thought_payload_requires_replay_tag\n *\n * Flags `new Thought({ … })` whose options literal sets a `payload` but omits a\n * `replayCompatibility` tag.\n *\n * Why: a `Thought` may carry a vendor-opaque `payload` that the harness cannot interpret, to be\n * replayed back to a matching model wire. The ADK can only route that payload if the thought also\n * declares which adapter wire-shape it is replayable into, via `replayCompatibility`. A `payload`\n * with no `replayCompatibility` is a footgun: the harness has no way to know which adapter can\n * consume it, so it is dropped silently. The `Thought` constructor enforces this cross-field\n * invariant at runtime (`payload` present ⇒ `replayCompatibility` required); this rule surfaces it\n * statically at the construction site so it fails lint, not just at runtime.\n *\n * Detects the common literal form: a `new Thought({ … })` options object that has a `payload`\n * property but no `replayCompatibility` property. Spreads or computed keys are not analyzable here —\n * those fall back to the runtime check.\n *\n * Opt-out:\n *   // eslint-disable-next-line adk/thought-payload-requires-replay-tag -- <reason>\n */\n\nimport { createRule } from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\nconst literalKey = (prop: TSESTree.Property): string | undefined => {\n  if (prop.computed) return undefined\n  if (prop.key.type === 'Identifier') return prop.key.name\n  if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') return prop.key.value\n  return undefined\n}\n\n// True when the property value is statically `undefined` (the absent case) — `payload: undefined`\n// is equivalent to omitting it, so it should not trigger the rule.\nconst isUndefinedValue = (node: TSESTree.Node): boolean =>\n  node.type === 'Identifier' && node.name === 'undefined'\n\n/** ESLint rule: flags a Thought constructed with a payload but no replayCompatibility tag. */\nconst thoughtPayloadRequiresReplayTagRule = createRule({\n  name: 'thought-payload-requires-replay-tag',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        'A `Thought` carrying a `payload` must declare `replayCompatibility`; otherwise the harness cannot route the opaque payload to a matching adapter and drops it. Enforced at runtime by the Thought constructor; this surfaces it at the construction site.',\n    },\n    schema: [],\n    messages: {\n      requireReplayTag:\n        '`new Thought({ payload })` requires a `replayCompatibility` tag — without it the harness cannot route the opaque payload to an adapter and silently drops it. Add `replayCompatibility: \"<wire-shape-id>\"`, or remove the payload. Opt out with an eslint-disable-next-line adk/thought-payload-requires-replay-tag comment + reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      NewExpression(node: TSESTree.NewExpression) {\n        if (node.callee.type !== 'Identifier' || node.callee.name !== 'Thought') return\n        const arg = node.arguments[0]\n        if (!arg || arg.type !== 'ObjectExpression') return\n\n        let payloadProp: TSESTree.Property | undefined\n        let hasReplayTag = false\n        let hasSpread = false\n        for (const p of arg.properties) {\n          if (p.type === 'SpreadElement') {\n            hasSpread = true\n            continue\n          }\n          const key = literalKey(p)\n          if (key === 'payload' && !isUndefinedValue(p.value)) payloadProp = p\n          else if (key === 'replayCompatibility' && !isUndefinedValue(p.value)) hasReplayTag = true\n        }\n\n        // A spread could supply replayCompatibility we can't see — stay conservative, don't flag.\n        if (payloadProp && !hasReplayTag && !hasSpread) {\n          context.report({ node: payloadProp, messageId: 'requireReplayTag' })\n        }\n      },\n    }\n  },\n})\n\nexport default thoughtPayloadRequiresReplayTagRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA0BA,IAAM,cAAc,SAAgD;CAClE,IAAI,KAAK,UAAU,OAAO,KAAA;CAC1B,IAAI,KAAK,IAAI,SAAS,cAAc,OAAO,KAAK,IAAI;CACpD,IAAI,KAAK,IAAI,SAAS,aAAa,OAAO,KAAK,IAAI,UAAU,UAAU,OAAO,KAAK,IAAI;AAEzF;AAIA,IAAM,oBAAoB,SACxB,KAAK,SAAS,gBAAgB,KAAK,SAAS;;AAG9C,IAAM,sCAAsC,WAAW;CACrD,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,4PACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,kBACE,0UACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,cAAc,MAA8B;GAC1C,IAAI,KAAK,OAAO,SAAS,gBAAgB,KAAK,OAAO,SAAS,WAAW;GACzE,MAAM,MAAM,KAAK,UAAU;GAC3B,IAAI,CAAC,OAAO,IAAI,SAAS,oBAAoB;GAE7C,IAAI;GACJ,IAAI,eAAe;GACnB,IAAI,YAAY;GAChB,KAAK,MAAM,KAAK,IAAI,YAAY;IAC9B,IAAI,EAAE,SAAS,iBAAiB;KAC9B,YAAY;KACZ;IACF;IACA,MAAM,MAAM,WAAW,CAAC;IACxB,IAAI,QAAQ,aAAa,CAAC,iBAAiB,EAAE,KAAK,GAAG,cAAc;SAC9D,IAAI,QAAQ,yBAAyB,CAAC,iBAAiB,EAAE,KAAK,GAAG,eAAe;GACvF;GAGA,IAAI,eAAe,CAAC,gBAAgB,CAAC,WACnC,QAAQ,OAAO;IAAE,MAAM;IAAa,WAAW;GAAmB,CAAC;EAEvE,EACF;CACF;AACF,CAAC"}

package/eslint/rules/token_encoding_requires_context_window.cjs

@@ -30,6 +30,7 @@ var literalKey = (prop) => {
 	if (prop.key.type === "Literal" && typeof prop.key.value === "string") return prop.key.value;
 };
 var isNullOrUndefined = (node) => node.type === "Literal" && node.value === null || node.type === "Identifier" && node.name === "undefined";
+/** ESLint rule: flags setting a tokenEncoding without also setting a contextWindow. */
 var tokenEncodingRequiresContextWindowRule = require_common.createRule({
 	name: "token-encoding-requires-context-window",
 	meta: {

package/eslint/rules/token_encoding_requires_context_window.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"token_encoding_requires_context_window.cjs","names":[],"sources":["../../../src/eslint/rules/token_encoding_requires_context_window.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/token_encoding_requires_context_window\n *\n * Flags a Chat Completions adapter options literal that sets a non-null `tokenEncoding` but omits\n * `contextWindow`.\n *\n * Why: the OpenAI / WebLLM Chat Completions batteries only perform local token counting + overflow\n * protection when BOTH `tokenEncoding` (how to count) and `contextWindow` (the budget to count\n * against) are provided. Setting `tokenEncoding` alone is a footgun — the encoding is configured but\n * there is no ceiling to enforce, so the overflow guard silently never runs. The adapters throw on\n * this cross-field mismatch at iteration time; this rule surfaces it at the construction site.\n *\n * Detects `new OpenAIChatCompletionsAdapter({ … })` / `new WebLLMChatCompletionsAdapter({ … })`\n * (and any `*ChatCompletionsAdapter`) where `tokenEncoding` is present and not `null`/`undefined`\n * while `contextWindow` is absent.\n *\n * Opt-out:\n *   // eslint-disable-next-line adk/token-encoding-requires-context-window -- <reason>\n */\n\nimport { createRule } from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\nconst literalKey = (prop: TSESTree.Property): string | undefined => {\n  if (prop.computed) return undefined\n  if (prop.key.type === 'Identifier') return prop.key.name\n  if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') return prop.key.value\n  return undefined\n}\n\nconst isNullOrUndefined = (node: TSESTree.Node): boolean =>\n  (node.type === 'Literal' && node.value === null) ||\n  (node.type === 'Identifier' && node.name === 'undefined')\n\nconst tokenEncodingRequiresContextWindowRule = createRule({\n  name: 'token-encoding-requires-context-window',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        'A Chat Completions adapter configured with a non-null `tokenEncoding` must also set `contextWindow`; otherwise token counting is configured but the overflow guard has no budget and never runs. The adapters enforce this at runtime; this surfaces it at the construction site.',\n    },\n    schema: [],\n    messages: {\n      requireContextWindow:\n        '`tokenEncoding` is set but `contextWindow` is missing — the adapter counts tokens with no budget to enforce, so the context-overflow guard never runs. Add `contextWindow`, or drop `tokenEncoding`. Opt out with an eslint-disable-next-line adk/token-encoding-requires-context-window comment + reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      NewExpression(node: TSESTree.NewExpression) {\n        if (node.callee.type !== 'Identifier') return\n        if (!/ChatCompletionsAdapter$/.test(node.callee.name)) return\n        const arg = node.arguments[0]\n        if (!arg || arg.type !== 'ObjectExpression') return\n\n        let tokenEncodingProp: TSESTree.Property | undefined\n        let hasContextWindow = false\n        let hasSpread = false\n        for (const p of arg.properties) {\n          if (p.type === 'SpreadElement') {\n            hasSpread = true\n            continue\n          }\n          const key = literalKey(p)\n          if (key === 'tokenEncoding' && !isNullOrUndefined(p.value)) tokenEncodingProp = p\n          else if (key === 'contextWindow' && !isNullOrUndefined(p.value)) hasContextWindow = true\n        }\n\n        // A spread could supply contextWindow we can't see — stay conservative, don't flag.\n        if (tokenEncodingProp && !hasContextWindow && !hasSpread) {\n          context.report({ node: tokenEncodingProp, messageId: 'requireContextWindow' })\n        }\n      },\n    }\n  },\n})\n\nexport default tokenEncodingRequiresContextWindowRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,IAAM,cAAc,SAAgD;CAClE,IAAI,KAAK,UAAU,OAAO,KAAA;CAC1B,IAAI,KAAK,IAAI,SAAS,cAAc,OAAO,KAAK,IAAI;CACpD,IAAI,KAAK,IAAI,SAAS,aAAa,OAAO,KAAK,IAAI,UAAU,UAAU,OAAO,KAAK,IAAI;AAEzF;AAEA,IAAM,qBAAqB,SACxB,KAAK,SAAS,aAAa,KAAK,UAAU,QAC1C,KAAK,SAAS,gBAAgB,KAAK,SAAS;AAE/C,IAAM,yCAAyC,eAAA,WAAW;CACxD,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,oRACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,sBACE,6SACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,cAAc,MAA8B;GAC1C,IAAI,KAAK,OAAO,SAAS,cAAc;GACvC,IAAI,CAAC,0BAA0B,KAAK,KAAK,OAAO,IAAI,GAAG;GACvD,MAAM,MAAM,KAAK,UAAU;GAC3B,IAAI,CAAC,OAAO,IAAI,SAAS,oBAAoB;GAE7C,IAAI;GACJ,IAAI,mBAAmB;GACvB,IAAI,YAAY;GAChB,KAAK,MAAM,KAAK,IAAI,YAAY;IAC9B,IAAI,EAAE,SAAS,iBAAiB;KAC9B,YAAY;KACZ;IACF;IACA,MAAM,MAAM,WAAW,CAAC;IACxB,IAAI,QAAQ,mBAAmB,CAAC,kBAAkB,EAAE,KAAK,GAAG,oBAAoB;SAC3E,IAAI,QAAQ,mBAAmB,CAAC,kBAAkB,EAAE,KAAK,GAAG,mBAAmB;GACtF;GAGA,IAAI,qBAAqB,CAAC,oBAAoB,CAAC,WAC7C,QAAQ,OAAO;IAAE,MAAM;IAAmB,WAAW;GAAuB,CAAC;EAEjF,EACF;CACF;AACF,CAAC"}
+{"version":3,"file":"token_encoding_requires_context_window.cjs","names":[],"sources":["../../../src/eslint/rules/token_encoding_requires_context_window.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/token_encoding_requires_context_window\n *\n * Flags a Chat Completions adapter options literal that sets a non-null `tokenEncoding` but omits\n * `contextWindow`.\n *\n * Why: the OpenAI / WebLLM Chat Completions batteries only perform local token counting + overflow\n * protection when BOTH `tokenEncoding` (how to count) and `contextWindow` (the budget to count\n * against) are provided. Setting `tokenEncoding` alone is a footgun — the encoding is configured but\n * there is no ceiling to enforce, so the overflow guard silently never runs. The adapters throw on\n * this cross-field mismatch at iteration time; this rule surfaces it at the construction site.\n *\n * Detects `new OpenAIChatCompletionsAdapter({ … })` / `new WebLLMChatCompletionsAdapter({ … })`\n * (and any `*ChatCompletionsAdapter`) where `tokenEncoding` is present and not `null`/`undefined`\n * while `contextWindow` is absent.\n *\n * Opt-out:\n *   // eslint-disable-next-line adk/token-encoding-requires-context-window -- <reason>\n */\n\nimport { createRule } from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\nconst literalKey = (prop: TSESTree.Property): string | undefined => {\n  if (prop.computed) return undefined\n  if (prop.key.type === 'Identifier') return prop.key.name\n  if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') return prop.key.value\n  return undefined\n}\n\nconst isNullOrUndefined = (node: TSESTree.Node): boolean =>\n  (node.type === 'Literal' && node.value === null) ||\n  (node.type === 'Identifier' && node.name === 'undefined')\n\n/** ESLint rule: flags setting a tokenEncoding without also setting a contextWindow. */\nconst tokenEncodingRequiresContextWindowRule = createRule({\n  name: 'token-encoding-requires-context-window',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        'A Chat Completions adapter configured with a non-null `tokenEncoding` must also set `contextWindow`; otherwise token counting is configured but the overflow guard has no budget and never runs. The adapters enforce this at runtime; this surfaces it at the construction site.',\n    },\n    schema: [],\n    messages: {\n      requireContextWindow:\n        '`tokenEncoding` is set but `contextWindow` is missing — the adapter counts tokens with no budget to enforce, so the context-overflow guard never runs. Add `contextWindow`, or drop `tokenEncoding`. Opt out with an eslint-disable-next-line adk/token-encoding-requires-context-window comment + reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      NewExpression(node: TSESTree.NewExpression) {\n        if (node.callee.type !== 'Identifier') return\n        if (!/ChatCompletionsAdapter$/.test(node.callee.name)) return\n        const arg = node.arguments[0]\n        if (!arg || arg.type !== 'ObjectExpression') return\n\n        let tokenEncodingProp: TSESTree.Property | undefined\n        let hasContextWindow = false\n        let hasSpread = false\n        for (const p of arg.properties) {\n          if (p.type === 'SpreadElement') {\n            hasSpread = true\n            continue\n          }\n          const key = literalKey(p)\n          if (key === 'tokenEncoding' && !isNullOrUndefined(p.value)) tokenEncodingProp = p\n          else if (key === 'contextWindow' && !isNullOrUndefined(p.value)) hasContextWindow = true\n        }\n\n        // A spread could supply contextWindow we can't see — stay conservative, don't flag.\n        if (tokenEncodingProp && !hasContextWindow && !hasSpread) {\n          context.report({ node: tokenEncodingProp, messageId: 'requireContextWindow' })\n        }\n      },\n    }\n  },\n})\n\nexport default tokenEncodingRequiresContextWindowRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,IAAM,cAAc,SAAgD;CAClE,IAAI,KAAK,UAAU,OAAO,KAAA;CAC1B,IAAI,KAAK,IAAI,SAAS,cAAc,OAAO,KAAK,IAAI;CACpD,IAAI,KAAK,IAAI,SAAS,aAAa,OAAO,KAAK,IAAI,UAAU,UAAU,OAAO,KAAK,IAAI;AAEzF;AAEA,IAAM,qBAAqB,SACxB,KAAK,SAAS,aAAa,KAAK,UAAU,QAC1C,KAAK,SAAS,gBAAgB,KAAK,SAAS;;AAG/C,IAAM,yCAAyC,eAAA,WAAW;CACxD,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,oRACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,sBACE,6SACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,cAAc,MAA8B;GAC1C,IAAI,KAAK,OAAO,SAAS,cAAc;GACvC,IAAI,CAAC,0BAA0B,KAAK,KAAK,OAAO,IAAI,GAAG;GACvD,MAAM,MAAM,KAAK,UAAU;GAC3B,IAAI,CAAC,OAAO,IAAI,SAAS,oBAAoB;GAE7C,IAAI;GACJ,IAAI,mBAAmB;GACvB,IAAI,YAAY;GAChB,KAAK,MAAM,KAAK,IAAI,YAAY;IAC9B,IAAI,EAAE,SAAS,iBAAiB;KAC9B,YAAY;KACZ;IACF;IACA,MAAM,MAAM,WAAW,CAAC;IACxB,IAAI,QAAQ,mBAAmB,CAAC,kBAAkB,EAAE,KAAK,GAAG,oBAAoB;SAC3E,IAAI,QAAQ,mBAAmB,CAAC,kBAAkB,EAAE,KAAK,GAAG,mBAAmB;GACtF;GAGA,IAAI,qBAAqB,CAAC,oBAAoB,CAAC,WAC7C,QAAQ,OAAO;IAAE,MAAM;IAAmB,WAAW;GAAuB,CAAC;EAEjF,EACF;CACF;AACF,CAAC"}

package/eslint/rules/token_encoding_requires_context_window.d.ts

@@ -17,6 +17,7 @@
  * Opt-out:
  *   // eslint-disable-next-line adk/token-encoding-requires-context-window -- <reason>
  */
+/** ESLint rule: flags setting a tokenEncoding without also setting a contextWindow. */
 declare const tokenEncodingRequiresContextWindowRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"requireContextWindow", [
 ], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;

package/eslint/rules/token_encoding_requires_context_window.mjs

@@ -25,6 +25,7 @@ var literalKey = (prop) => {
 	if (prop.key.type === "Literal" && typeof prop.key.value === "string") return prop.key.value;
 };
 var isNullOrUndefined = (node) => node.type === "Literal" && node.value === null || node.type === "Identifier" && node.name === "undefined";
+/** ESLint rule: flags setting a tokenEncoding without also setting a contextWindow. */
 var tokenEncodingRequiresContextWindowRule = createRule({
 	name: "token-encoding-requires-context-window",
 	meta: {

package/eslint/rules/token_encoding_requires_context_window.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"token_encoding_requires_context_window.mjs","names":[],"sources":["../../../src/eslint/rules/token_encoding_requires_context_window.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/token_encoding_requires_context_window\n *\n * Flags a Chat Completions adapter options literal that sets a non-null `tokenEncoding` but omits\n * `contextWindow`.\n *\n * Why: the OpenAI / WebLLM Chat Completions batteries only perform local token counting + overflow\n * protection when BOTH `tokenEncoding` (how to count) and `contextWindow` (the budget to count\n * against) are provided. Setting `tokenEncoding` alone is a footgun — the encoding is configured but\n * there is no ceiling to enforce, so the overflow guard silently never runs. The adapters throw on\n * this cross-field mismatch at iteration time; this rule surfaces it at the construction site.\n *\n * Detects `new OpenAIChatCompletionsAdapter({ … })` / `new WebLLMChatCompletionsAdapter({ … })`\n * (and any `*ChatCompletionsAdapter`) where `tokenEncoding` is present and not `null`/`undefined`\n * while `contextWindow` is absent.\n *\n * Opt-out:\n *   // eslint-disable-next-line adk/token-encoding-requires-context-window -- <reason>\n */\n\nimport { createRule } from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\nconst literalKey = (prop: TSESTree.Property): string | undefined => {\n  if (prop.computed) return undefined\n  if (prop.key.type === 'Identifier') return prop.key.name\n  if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') return prop.key.value\n  return undefined\n}\n\nconst isNullOrUndefined = (node: TSESTree.Node): boolean =>\n  (node.type === 'Literal' && node.value === null) ||\n  (node.type === 'Identifier' && node.name === 'undefined')\n\nconst tokenEncodingRequiresContextWindowRule = createRule({\n  name: 'token-encoding-requires-context-window',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        'A Chat Completions adapter configured with a non-null `tokenEncoding` must also set `contextWindow`; otherwise token counting is configured but the overflow guard has no budget and never runs. The adapters enforce this at runtime; this surfaces it at the construction site.',\n    },\n    schema: [],\n    messages: {\n      requireContextWindow:\n        '`tokenEncoding` is set but `contextWindow` is missing — the adapter counts tokens with no budget to enforce, so the context-overflow guard never runs. Add `contextWindow`, or drop `tokenEncoding`. Opt out with an eslint-disable-next-line adk/token-encoding-requires-context-window comment + reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      NewExpression(node: TSESTree.NewExpression) {\n        if (node.callee.type !== 'Identifier') return\n        if (!/ChatCompletionsAdapter$/.test(node.callee.name)) return\n        const arg = node.arguments[0]\n        if (!arg || arg.type !== 'ObjectExpression') return\n\n        let tokenEncodingProp: TSESTree.Property | undefined\n        let hasContextWindow = false\n        let hasSpread = false\n        for (const p of arg.properties) {\n          if (p.type === 'SpreadElement') {\n            hasSpread = true\n            continue\n          }\n          const key = literalKey(p)\n          if (key === 'tokenEncoding' && !isNullOrUndefined(p.value)) tokenEncodingProp = p\n          else if (key === 'contextWindow' && !isNullOrUndefined(p.value)) hasContextWindow = true\n        }\n\n        // A spread could supply contextWindow we can't see — stay conservative, don't flag.\n        if (tokenEncodingProp && !hasContextWindow && !hasSpread) {\n          context.report({ node: tokenEncodingProp, messageId: 'requireContextWindow' })\n        }\n      },\n    }\n  },\n})\n\nexport default tokenEncodingRequiresContextWindowRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAwBA,IAAM,cAAc,SAAgD;CAClE,IAAI,KAAK,UAAU,OAAO,KAAA;CAC1B,IAAI,KAAK,IAAI,SAAS,cAAc,OAAO,KAAK,IAAI;CACpD,IAAI,KAAK,IAAI,SAAS,aAAa,OAAO,KAAK,IAAI,UAAU,UAAU,OAAO,KAAK,IAAI;AAEzF;AAEA,IAAM,qBAAqB,SACxB,KAAK,SAAS,aAAa,KAAK,UAAU,QAC1C,KAAK,SAAS,gBAAgB,KAAK,SAAS;AAE/C,IAAM,yCAAyC,WAAW;CACxD,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,oRACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,sBACE,6SACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,cAAc,MAA8B;GAC1C,IAAI,KAAK,OAAO,SAAS,cAAc;GACvC,IAAI,CAAC,0BAA0B,KAAK,KAAK,OAAO,IAAI,GAAG;GACvD,MAAM,MAAM,KAAK,UAAU;GAC3B,IAAI,CAAC,OAAO,IAAI,SAAS,oBAAoB;GAE7C,IAAI;GACJ,IAAI,mBAAmB;GACvB,IAAI,YAAY;GAChB,KAAK,MAAM,KAAK,IAAI,YAAY;IAC9B,IAAI,EAAE,SAAS,iBAAiB;KAC9B,YAAY;KACZ;IACF;IACA,MAAM,MAAM,WAAW,CAAC;IACxB,IAAI,QAAQ,mBAAmB,CAAC,kBAAkB,EAAE,KAAK,GAAG,oBAAoB;SAC3E,IAAI,QAAQ,mBAAmB,CAAC,kBAAkB,EAAE,KAAK,GAAG,mBAAmB;GACtF;GAGA,IAAI,qBAAqB,CAAC,oBAAoB,CAAC,WAC7C,QAAQ,OAAO;IAAE,MAAM;IAAmB,WAAW;GAAuB,CAAC;EAEjF,EACF;CACF;AACF,CAAC"}
+{"version":3,"file":"token_encoding_requires_context_window.mjs","names":[],"sources":["../../../src/eslint/rules/token_encoding_requires_context_window.ts"],"sourcesContent":["/**\n * @module @nhtio/adk/eslint/rules/token_encoding_requires_context_window\n *\n * Flags a Chat Completions adapter options literal that sets a non-null `tokenEncoding` but omits\n * `contextWindow`.\n *\n * Why: the OpenAI / WebLLM Chat Completions batteries only perform local token counting + overflow\n * protection when BOTH `tokenEncoding` (how to count) and `contextWindow` (the budget to count\n * against) are provided. Setting `tokenEncoding` alone is a footgun — the encoding is configured but\n * there is no ceiling to enforce, so the overflow guard silently never runs. The adapters throw on\n * this cross-field mismatch at iteration time; this rule surfaces it at the construction site.\n *\n * Detects `new OpenAIChatCompletionsAdapter({ … })` / `new WebLLMChatCompletionsAdapter({ … })`\n * (and any `*ChatCompletionsAdapter`) where `tokenEncoding` is present and not `null`/`undefined`\n * while `contextWindow` is absent.\n *\n * Opt-out:\n *   // eslint-disable-next-line adk/token-encoding-requires-context-window -- <reason>\n */\n\nimport { createRule } from './common'\n\nimport type { TSESTree } from '@typescript-eslint/utils'\n\nconst literalKey = (prop: TSESTree.Property): string | undefined => {\n  if (prop.computed) return undefined\n  if (prop.key.type === 'Identifier') return prop.key.name\n  if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') return prop.key.value\n  return undefined\n}\n\nconst isNullOrUndefined = (node: TSESTree.Node): boolean =>\n  (node.type === 'Literal' && node.value === null) ||\n  (node.type === 'Identifier' && node.name === 'undefined')\n\n/** ESLint rule: flags setting a tokenEncoding without also setting a contextWindow. */\nconst tokenEncodingRequiresContextWindowRule = createRule({\n  name: 'token-encoding-requires-context-window',\n  meta: {\n    type: 'problem',\n    docs: {\n      description:\n        'A Chat Completions adapter configured with a non-null `tokenEncoding` must also set `contextWindow`; otherwise token counting is configured but the overflow guard has no budget and never runs. The adapters enforce this at runtime; this surfaces it at the construction site.',\n    },\n    schema: [],\n    messages: {\n      requireContextWindow:\n        '`tokenEncoding` is set but `contextWindow` is missing — the adapter counts tokens with no budget to enforce, so the context-overflow guard never runs. Add `contextWindow`, or drop `tokenEncoding`. Opt out with an eslint-disable-next-line adk/token-encoding-requires-context-window comment + reason.',\n    },\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      NewExpression(node: TSESTree.NewExpression) {\n        if (node.callee.type !== 'Identifier') return\n        if (!/ChatCompletionsAdapter$/.test(node.callee.name)) return\n        const arg = node.arguments[0]\n        if (!arg || arg.type !== 'ObjectExpression') return\n\n        let tokenEncodingProp: TSESTree.Property | undefined\n        let hasContextWindow = false\n        let hasSpread = false\n        for (const p of arg.properties) {\n          if (p.type === 'SpreadElement') {\n            hasSpread = true\n            continue\n          }\n          const key = literalKey(p)\n          if (key === 'tokenEncoding' && !isNullOrUndefined(p.value)) tokenEncodingProp = p\n          else if (key === 'contextWindow' && !isNullOrUndefined(p.value)) hasContextWindow = true\n        }\n\n        // A spread could supply contextWindow we can't see — stay conservative, don't flag.\n        if (tokenEncodingProp && !hasContextWindow && !hasSpread) {\n          context.report({ node: tokenEncodingProp, messageId: 'requireContextWindow' })\n        }\n      },\n    }\n  },\n})\n\nexport default tokenEncodingRequiresContextWindowRule\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAwBA,IAAM,cAAc,SAAgD;CAClE,IAAI,KAAK,UAAU,OAAO,KAAA;CAC1B,IAAI,KAAK,IAAI,SAAS,cAAc,OAAO,KAAK,IAAI;CACpD,IAAI,KAAK,IAAI,SAAS,aAAa,OAAO,KAAK,IAAI,UAAU,UAAU,OAAO,KAAK,IAAI;AAEzF;AAEA,IAAM,qBAAqB,SACxB,KAAK,SAAS,aAAa,KAAK,UAAU,QAC1C,KAAK,SAAS,gBAAgB,KAAK,SAAS;;AAG/C,IAAM,yCAAyC,WAAW;CACxD,MAAM;CACN,MAAM;EACJ,MAAM;EACN,MAAM,EACJ,aACE,oRACJ;EACA,QAAQ,CAAC;EACT,UAAU,EACR,sBACE,6SACJ;CACF;CACA,gBAAgB,CAAC;CACjB,OAAO,SAAS;EACd,OAAO,EACL,cAAc,MAA8B;GAC1C,IAAI,KAAK,OAAO,SAAS,cAAc;GACvC,IAAI,CAAC,0BAA0B,KAAK,KAAK,OAAO,IAAI,GAAG;GACvD,MAAM,MAAM,KAAK,UAAU;GAC3B,IAAI,CAAC,OAAO,IAAI,SAAS,oBAAoB;GAE7C,IAAI;GACJ,IAAI,mBAAmB;GACvB,IAAI,YAAY;GAChB,KAAK,MAAM,KAAK,IAAI,YAAY;IAC9B,IAAI,EAAE,SAAS,iBAAiB;KAC9B,YAAY;KACZ;IACF;IACA,MAAM,MAAM,WAAW,CAAC;IACxB,IAAI,QAAQ,mBAAmB,CAAC,kBAAkB,EAAE,KAAK,GAAG,oBAAoB;SAC3E,IAAI,QAAQ,mBAAmB,CAAC,kBAAkB,EAAE,KAAK,GAAG,mBAAmB;GACtF;GAGA,IAAI,qBAAqB,CAAC,oBAAoB,CAAC,WAC7C,QAAQ,OAAO;IAAE,MAAM;IAAmB,WAAW;GAAuB,CAAC;EAEjF,EACF;CACF;AACF,CAAC"}

package/eslint.cjs

@@ -49,7 +49,7 @@ var rules = {
 var plugin = {
 	meta: {
 		name: "@nhtio/adk/eslint",
-		version: "1.20260607.2"
+		version: "1.20260609.0"
 	},
 	rules
 };

package/eslint.mjs

@@ -44,7 +44,7 @@ var rules = {
 var plugin = {
 	meta: {
 		name: "@nhtio/adk/eslint",
-		version: "1.20260607.2"
+		version: "1.20260609.0"
 	},
 	rules
 };

package/{exceptions-BeWH2FwP.mjs → exceptions-BDhN0Xzr.mjs}

@@ -62,6 +62,7 @@ var BaseException = class BaseException extends Error {
 		if (help !== void 0) this.help = help;
 		Error.captureStackTrace(this, ErrorConstructor);
 	}
+	/** Tag used by `Object.prototype.toString` — reports the concrete exception class name. */
 	get [Symbol.toStringTag]() {
 		return this.constructor.name;
 	}
@@ -203,7 +204,7 @@ var asyncValidateOrThrow = async (schema, value, convert = false) => {
 * @typeParam T - Tuple of printf format argument types. Pass a non-empty tuple to require
 *   callers to supply interpolation values at the throw site.
 *
-* @param name - The `name` property set on thrown instances (used by {@link isNamedException}).
+* @param name - The `name` property set on thrown instances (used by `isNamedException`).
 * @param message - Printf-style template string for the error message.
 * @param code - Machine-readable error code stored on the static and instance `code` property.
 * @param status - HTTP status code associated with this exception class.
@@ -241,4 +242,4 @@ var createException = (name, message, code, status, fatal) => {
 //#endregion
 export { validateOrThrow as a, passesSchema as i, ValidationException as n, BaseException as o, asyncValidateOrThrow as r, createException as t };
 
-//# sourceMappingURL=exceptions-BeWH2FwP.mjs.map
+//# sourceMappingURL=exceptions-BDhN0Xzr.mjs.map

package/exceptions-BDhN0Xzr.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"exceptions-BDhN0Xzr.mjs","names":[],"sources":["../src/lib/classes/base_exception.ts","../src/lib/utils/validation.ts","../src/lib/utils/exceptions.ts"],"sourcesContent":["/**\n * Base class for all structured exceptions in the ADK.\n *\n * @remarks\n * Subclasses should declare static `code`, `status`, `fatal`, and optionally `help` to avoid\n * repeating those values on every instance. Instance-level options always take precedence over\n * static defaults, so a single exception class can still be thrown with per-site overrides when\n * needed.\n *\n * The runtime cross-realm guard is inlined here rather than imported from `../utils/guards`\n * to break a circular-import chain: `guards` depends on `validation`, which extends\n * `BaseException`. Importing the shared `isInstanceOf` helper into this file would create a\n * load-order cycle that leaves `BaseException` undefined when `ValidationException extends\n * BaseException` evaluates.\n */\nexport class BaseException extends Error {\n  /**\n   * Returns `true` if `value` is a {@link BaseException} instance.\n   *\n   * @remarks\n   * Performs cross-realm-safe detection: tries `instanceof`, then `Symbol.hasInstance`, then\n   * constructor-name comparison. The ADK does not export the `BaseException` class itself\n   * as a constructable value — use this guard plus the {@link BaseException} type for runtime\n   * detection and TypeScript narrowing.\n   *\n   * @param value - The value to test.\n   * @returns `true` when `value` is a {@link BaseException} instance.\n   */\n  public static isBaseException(value: unknown): value is BaseException {\n    // eslint-disable-next-line adk/use-is-instance-of -- module cycle (guards ↔ validation ↔ BaseException); the cross-realm fallback is inlined below\n    if (value instanceof BaseException) return true\n    if (\n      typeof BaseException[Symbol.hasInstance] === 'function' &&\n      BaseException[Symbol.hasInstance](value)\n    )\n      return true\n    // eslint-disable-next-line adk/prefer-is-object -- module cycle (guards ↔ validation ↔ BaseException); isObject would create a load-order cycle\n    if (typeof value === 'object' && value !== null) {\n      const ctorName = (value as { constructor?: { name?: string } }).constructor?.name\n      if (ctorName === 'BaseException') return true\n    }\n    return false\n  }\n  /**\n   * Default help text inherited by all instances unless overridden at the throw site.\n   */\n  declare static help?: string\n  /**\n   * Default machine-readable error code inherited by all instances.\n   */\n  declare static code?: string\n  /**\n   * Default HTTP status code inherited by all instances.\n   */\n  declare static status?: number\n  /**\n   * Whether exceptions of this class are fatal by default.\n   */\n  declare static fatal?: boolean\n  /**\n   * Default message used when no message is supplied to the constructor.\n   */\n  declare static message?: string\n\n  /**\n   * Name of the class that raised the exception.\n   */\n  name: string\n\n  /**\n   * Human-readable guidance for resolving or reporting this error.\n   */\n  declare help?: string\n\n  /**\n   * Machine-readable error code for narrowing exception-handling logic.\n   */\n  declare code?: string\n\n  /**\n   * HTTP status code associated with this error.\n   */\n  declare status?: number\n\n  /**\n   * When `true`, the ADK treats this error as unrecoverable and should halt the agent loop.\n   */\n  declare fatal?: boolean\n\n  /**\n   * @param message - Human-readable error message. Falls back to the static `message` on the\n   *   subclass if omitted.\n   * @param options - Standard `ErrorOptions` extended with `code`, `status`, and `fatal`\n   *   overrides. Static defaults on the subclass are used when these are absent.\n   */\n  constructor(\n    message?: string,\n    options?: ErrorOptions & { code?: string; status?: number; fatal?: boolean }\n  ) {\n    super(message, options)\n\n    const ErrorConstructor = this.constructor as typeof BaseException\n\n    this.name = ErrorConstructor.name\n    this.message = message || ErrorConstructor.message || ''\n\n    const code = options?.code || ErrorConstructor.code\n    if (code !== undefined) {\n      this.code = code\n    }\n\n    const status = options?.status || ErrorConstructor.status\n    if (status !== undefined) {\n      this.status = status\n    }\n\n    const fatal = options?.fatal ?? ErrorConstructor.fatal\n    if (fatal !== undefined) {\n      this.fatal = fatal\n    }\n\n    const help = ErrorConstructor.help\n    if (help !== undefined) {\n      this.help = help\n    }\n\n    Error.captureStackTrace(this, ErrorConstructor)\n  }\n\n  /** Tag used by `Object.prototype.toString` — reports the concrete exception class name. */\n  get [Symbol.toStringTag]() {\n    return this.constructor.name\n  }\n\n  toString() {\n    if (this.code) {\n      return `${this.name} [${this.code}]: ${this.message}`\n    }\n    return `${this.name}: ${this.message}`\n  }\n}\n","import { BaseException } from '../classes/base_exception'\nimport { validator, ValidationError } from '@nhtio/validation'\nimport type { Schema } from '@nhtio/validation'\n\n/**\n * Returns `true` if `value` satisfies `schema` without throwing.\n *\n * @remarks\n * Aborts on the first validation error. Use {@link validateOrThrow} or\n * {@link asyncValidateOrThrow} when you need the full set of field errors.\n *\n * @param schema - The schema to validate against.\n * @param value - The value to test.\n * @returns `true` when `value` passes the schema; `false` otherwise.\n */\nexport const passesSchema = (schema: Schema, value: unknown): boolean => {\n  const { error } = schema.validate(value, { abortEarly: true })\n  return !error\n}\n\n/**\n * Returns `true` if `value` is a `ValidationError` or satisfies its minimum duck-type shape.\n *\n * @remarks\n * The duck-typing path handles `ValidationError` objects that cross module or realm boundaries\n * where `instanceof` would return `false`.\n *\n * @param value - The value to test.\n * @returns `true` when `value` conforms to the `ValidationError` shape.\n */\nexport const isValidationError = (value: unknown): value is ValidationError => {\n  const schema = validator.alternatives(\n    validator.object().instance(ValidationError as any),\n    validator.function().instance(ValidationError as any),\n    validator\n      .object({\n        message: validator.string().required(),\n        details: validator\n          .array()\n          .items(\n            validator.object({\n              message: validator.string().required(),\n              path: validator\n                .array()\n                .items(validator.alternatives(validator.string(), validator.number()))\n                .required(),\n              type: validator.string().required(),\n              context: validator.object().unknown(true).required(),\n            })\n          )\n          .required(),\n      })\n      .unknown(true)\n  )\n  return passesSchema(schema, value)\n}\n\nconst messageFromValidationError = (reason: ValidationError | undefined, fallback: string) => {\n  return reason ? reason.details.map((d) => d.message).join(' and ') : fallback\n}\n\n/**\n * Thrown when input fails schema validation.\n *\n * @remarks\n * Carries the full `details` array from the underlying `ValidationError` so callers can surface\n * field-level messages without unwrapping the `cause` manually.\n */\nexport class ValidationException extends BaseException {\n  static status = 422\n  static code = 'VALIDATION_EXCEPTION'\n  static fatal = false\n\n  /** The raw field-level error details from the underlying `ValidationError`. */\n  declare readonly details?: ValidationError['details']\n\n  /**\n   * @param reason - The `ValidationError` thrown by the schema; its `details` are surfaced\n   *   directly on this exception and its messages are joined to form the human-readable message.\n   */\n  constructor(reason: ValidationError) {\n    const message = messageFromValidationError(reason, 'Validation failed')\n    super(message, {\n      code: ValidationException.code,\n      status: ValidationException.status,\n      fatal: ValidationException.fatal,\n      cause: reason,\n    })\n    Object.defineProperty(this, 'details', {\n      value: reason.details,\n      enumerable: true,\n      configurable: false,\n      writable: false,\n    })\n  }\n}\n\n/**\n * Validates `value` against `schema` synchronously and returns the coerced result typed as `T`.\n *\n * @remarks\n * Collects all field errors before throwing. Use {@link asyncValidateOrThrow} for schemas that\n * include async custom validators.\n *\n * @typeParam T - The expected type of `value` after successful validation.\n * @param schema - The schema to validate against.\n * @param value - The value to validate.\n * @param convert - When `true`, the validator coerces values to their target types (e.g. string\n *   `\"1\"` → number `1`). Defaults to `false` to prevent silent type coercion.\n * @returns The validated (and optionally coerced) value typed as `T`.\n * @throws {@link ValidationException} when `value` does not satisfy `schema`.\n */\nexport const validateOrThrow = <T>(schema: Schema, value: unknown, convert: boolean = false): T => {\n  const { value: returnable, error } = schema.validate(value, { abortEarly: false, convert })\n  if (error) {\n    throw new ValidationException(error)\n  }\n  return returnable as T\n}\n\n/**\n * Validates `value` against `schema` asynchronously and returns the coerced result typed as `T`.\n *\n * @remarks\n * Collects all field errors before throwing. Prefer this over {@link validateOrThrow} when the\n * schema includes async custom validators.\n *\n * @typeParam T - The expected type of the validated and coerced return value.\n * @param schema - The schema to validate against.\n * @param value - The value to validate.\n * @param convert - When `true`, the validator coerces values to their target types (e.g. string\n *   `\"1\"` → number `1`). Defaults to `false` to prevent silent type coercion.\n * @returns The validated (and optionally coerced) value typed as `T`.\n * @throws {@link ValidationException} when `value` does not satisfy `schema`.\n */\nexport const asyncValidateOrThrow = async <T>(\n  schema: Schema,\n  value: unknown,\n  convert: boolean = false\n): Promise<T> => {\n  try {\n    return await schema.validateAsync(value, { abortEarly: false, convert })\n  } catch (error) {\n    if (isValidationError(error)) {\n      throw new ValidationException(error)\n    }\n    throw error\n  }\n}\n","import { passesSchema } from './validation'\nimport { validator } from '@nhtio/validation'\nimport { printf as format } from 'fast-printf'\nimport { BaseException } from '../classes/base_exception'\n\n/**\n * Options accepted by {@link @nhtio/adk!BaseException} (and factory-created exceptions) beyond the\n * standard `ErrorOptions`.\n *\n * @remarks\n * These mirror the static defaults on {@link @nhtio/adk!BaseException} but allow per-throw overrides so a\n * single exception class can carry different metadata at different throw sites.\n */\nexport type ExceptionOptions = ErrorOptions & {\n  code?: string\n  status?: number\n  fatal?: boolean\n}\n\n/**\n * Constructor signature of an exception class produced by {@link createException}.\n *\n * @typeParam T - Tuple of printf-style format argument types. When `T` is an empty tuple the\n *   constructor takes no positional message arguments; when non-empty the first argument must be\n *   an array of values matching `T`.\n */\nexport type CreatedException<T extends any[] = []> = typeof BaseException &\n  (T extends []\n    ? {\n        new (options?: ExceptionOptions): BaseException\n      }\n    : { new (args: T, options?: ExceptionOptions): BaseException })\n\n/**\n * Factory that produces a named {@link @nhtio/adk!BaseException} subclass with a fixed printf-style message\n * template, error code, HTTP status, and fatality flag.\n *\n * @remarks\n * Prefer this over hand-writing subclasses for simple, static exception definitions.\n *\n * @typeParam T - Tuple of printf format argument types. Pass a non-empty tuple to require\n *   callers to supply interpolation values at the throw site.\n *\n * @param name - The `name` property set on thrown instances (used by `isNamedException`).\n * @param message - Printf-style template string for the error message.\n * @param code - Machine-readable error code stored on the static and instance `code` property.\n * @param status - HTTP status code associated with this exception class.\n * @param fatal - When `true`, signals that the error is unrecoverable.\n * @returns A constructor for a {@link @nhtio/adk!BaseException} subclass with the given metadata baked in.\n *\n * @example\n * ```ts\n * export const E_NOT_FOUND = createException<[string]>(\n *   'E_NOT_FOUND', 'Resource %s not found', 'E_NOT_FOUND', 404, false\n * )\n * throw new E_NOT_FOUND(['my-id'])\n * ```\n */\nexport const createException = <T extends any[] = []>(\n  name: string,\n  message: string,\n  code: string,\n  status?: number,\n  fatal?: boolean\n): CreatedException<T> => {\n  const Ctor = class extends BaseException {\n    static message = message\n    static code = code\n    static status = status\n    static fatal = fatal\n    constructor(args?: T | ExceptionOptions, options?: ExceptionOptions) {\n      const hasMessageArgs = Array.isArray(args)\n      const messageArgs = hasMessageArgs ? args : []\n      const errorOptions = hasMessageArgs ? options : args\n\n      super(format(message, ...messageArgs), errorOptions)\n      this.name = name\n    }\n  }\n  // Without this, the factory returns an anonymous class — constructor.name is \"\" and\n  // cross-realm `isInstanceOf(err, 'E_FOO')` (which falls back to constructor-name comparison)\n  // never matches. Setting the name on the class itself makes the identity carry through.\n  Object.defineProperty(Ctor, 'name', { value: name, configurable: true })\n  return Ctor as unknown as CreatedException<T>\n}\n\n/**\n * Returns `true` if `value` is a {@link @nhtio/adk!BaseException} or satisfies its minimum duck-type shape.\n *\n * @remarks\n * The duck-typing path handles exceptions that cross module or realm boundaries where\n * `instanceof` would return `false` for structurally identical objects.\n *\n * @param value - The value to test.\n * @returns `true` when `value` conforms to the {@link @nhtio/adk!BaseException} shape.\n */\nexport const isException = (value: unknown): value is BaseException => {\n  const schema = validator.alternatives(\n    validator.object().instance(BaseException as any),\n    validator.function().instance(BaseException as any),\n    validator\n      .object({\n        name: validator.string().required(),\n        message: validator.string().required(),\n        help: validator.string().optional(),\n        code: validator.string().optional(),\n        status: validator.number().optional(),\n        fatal: validator.boolean().optional(),\n      })\n      .unknown(true)\n  )\n  return passesSchema(schema, value)\n}\n\n/**\n * Narrows `value` to a {@link @nhtio/adk!BaseException} whose `name` property matches `name` exactly.\n *\n * @remarks\n * Useful for catching a specific factory-created exception by its string identifier when\n * `instanceof` checks are not available (e.g. across module boundaries).\n *\n * @param value - The value to test.\n * @param name - The exact string to compare against `value.name`.\n * @returns `true` when `value` is a {@link @nhtio/adk!BaseException} with the given `name`.\n */\nexport const isNamedException = (value: unknown, name: string): value is BaseException => {\n  return isException(value) && value.name === name\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAeA,IAAa,gBAAb,MAAa,sBAAsB,MAAM;;;;;;;;;;;;;CAavC,OAAc,gBAAgB,OAAwC;EAEpE,IAAI,iBAAiB,eAAe,OAAO;EAC3C,IACE,OAAO,cAAc,OAAO,iBAAiB,cAC7C,cAAc,OAAO,aAAa,KAAK,GAEvC,OAAO;EAET,IAAI,OAAO,UAAU,YAAY,UAAU;OACvB,MAA8C,aAAa,SAC5D,iBAAiB,OAAO;EAAA;EAE3C,OAAO;CACT;;;;CAyBA;;;;;;;CA4BA,YACE,SACA,SACA;EACA,MAAM,SAAS,OAAO;EAEtB,MAAM,mBAAmB,KAAK;EAE9B,KAAK,OAAO,iBAAiB;EAC7B,KAAK,UAAU,WAAW,iBAAiB,WAAW;EAEtD,MAAM,OAAO,SAAS,QAAQ,iBAAiB;EAC/C,IAAI,SAAS,KAAA,GACX,KAAK,OAAO;EAGd,MAAM,SAAS,SAAS,UAAU,iBAAiB;EACnD,IAAI,WAAW,KAAA,GACb,KAAK,SAAS;EAGhB,MAAM,QAAQ,SAAS,SAAS,iBAAiB;EACjD,IAAI,UAAU,KAAA,GACZ,KAAK,QAAQ;EAGf,MAAM,OAAO,iBAAiB;EAC9B,IAAI,SAAS,KAAA,GACX,KAAK,OAAO;EAGd,MAAM,kBAAkB,MAAM,gBAAgB;CAChD;;CAGA,KAAK,OAAO,eAAe;EACzB,OAAO,KAAK,YAAY;CAC1B;CAEA,WAAW;EACT,IAAI,KAAK,MACP,OAAO,GAAG,KAAK,KAAK,IAAI,KAAK,KAAK,KAAK,KAAK;EAE9C,OAAO,GAAG,KAAK,KAAK,IAAI,KAAK;CAC/B;AACF;;;;;;;;;;;;;;AC7HA,IAAa,gBAAgB,QAAgB,UAA4B;CACvE,MAAM,EAAE,UAAU,OAAO,SAAS,OAAO,EAAE,YAAY,KAAK,CAAC;CAC7D,OAAO,CAAC;AACV;;;;;;;;;;;AAYA,IAAa,qBAAqB,UAA6C;CAwB7E,OAAO,aAvBQ,UAAU,aACvB,UAAU,OAAO,EAAE,SAAS,eAAsB,GAClD,UAAU,SAAS,EAAE,SAAS,eAAsB,GACpD,UACG,OAAO;EACN,SAAS,UAAU,OAAO,EAAE,SAAS;EACrC,SAAS,UACN,MAAM,EACN,MACC,UAAU,OAAO;GACf,SAAS,UAAU,OAAO,EAAE,SAAS;GACrC,MAAM,UACH,MAAM,EACN,MAAM,UAAU,aAAa,UAAU,OAAO,GAAG,UAAU,OAAO,CAAC,CAAC,EACpE,SAAS;GACZ,MAAM,UAAU,OAAO,EAAE,SAAS;GAClC,SAAS,UAAU,OAAO,EAAE,QAAQ,IAAI,EAAE,SAAS;EACrD,CAAC,CACH,EACC,SAAS;CACd,CAAC,EACA,QAAQ,IAAI,CAEG,GAAQ,KAAK;AACnC;AAEA,IAAM,8BAA8B,QAAqC,aAAqB;CAC5F,OAAO,SAAS,OAAO,QAAQ,KAAK,MAAM,EAAE,OAAO,EAAE,KAAK,OAAO,IAAI;AACvE;;;;;;;;AASA,IAAa,sBAAb,MAAa,4BAA4B,cAAc;CACrD,OAAO,SAAS;CAChB,OAAO,OAAO;CACd,OAAO,QAAQ;;;;;CASf,YAAY,QAAyB;EACnC,MAAM,UAAU,2BAA2B,QAAQ,mBAAmB;EACtE,MAAM,SAAS;GACb,MAAM,oBAAoB;GAC1B,QAAQ,oBAAoB;GAC5B,OAAO,oBAAoB;GAC3B,OAAO;EACT,CAAC;EACD,OAAO,eAAe,MAAM,WAAW;GACrC,OAAO,OAAO;GACd,YAAY;GACZ,cAAc;GACd,UAAU;EACZ,CAAC;CACH;AACF;;;;;;;;;;;;;;;;AAiBA,IAAa,mBAAsB,QAAgB,OAAgB,UAAmB,UAAa;CACjG,MAAM,EAAE,OAAO,YAAY,UAAU,OAAO,SAAS,OAAO;EAAE,YAAY;EAAO;CAAQ,CAAC;CAC1F,IAAI,OACF,MAAM,IAAI,oBAAoB,KAAK;CAErC,OAAO;AACT;;;;;;;;;;;;;;;;AAiBA,IAAa,uBAAuB,OAClC,QACA,OACA,UAAmB,UACJ;CACf,IAAI;EACF,OAAO,MAAM,OAAO,cAAc,OAAO;GAAE,YAAY;GAAO;EAAQ,CAAC;CACzE,SAAS,OAAO;EACd,IAAI,kBAAkB,KAAK,GACzB,MAAM,IAAI,oBAAoB,KAAK;EAErC,MAAM;CACR;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC1FA,IAAa,mBACX,MACA,SACA,MACA,QACA,UACwB;CACxB,MAAM,OAAO,cAAc,cAAc;EACvC,OAAO,UAAU;EACjB,OAAO,OAAO;EACd,OAAO,SAAS;EAChB,OAAO,QAAQ;EACf,YAAY,MAA6B,SAA4B;GACnE,MAAM,iBAAiB,MAAM,QAAQ,IAAI;GACzC,MAAM,cAAc,iBAAiB,OAAO,CAAC;GAC7C,MAAM,eAAe,iBAAiB,UAAU;GAEhD,MAAM,OAAO,SAAS,GAAG,WAAW,GAAG,YAAY;GACnD,KAAK,OAAO;EACd;CACF;CAIA,OAAO,eAAe,MAAM,QAAQ;EAAE,OAAO;EAAM,cAAc;CAAK,CAAC;CACvE,OAAO;AACT"}

package/{exceptions-CitH5wZI.js → exceptions-BRXrUKiW.js}

@@ -63,6 +63,7 @@ var BaseException = class BaseException extends Error {
 		if (help !== void 0) this.help = help;
 		Error.captureStackTrace(this, ErrorConstructor);
 	}
+	/** Tag used by `Object.prototype.toString` — reports the concrete exception class name. */
 	get [Symbol.toStringTag]() {
 		return this.constructor.name;
 	}
@@ -204,7 +205,7 @@ var asyncValidateOrThrow = async (schema, value, convert = false) => {
 * @typeParam T - Tuple of printf format argument types. Pass a non-empty tuple to require
 *   callers to supply interpolation values at the throw site.
 *
-* @param name - The `name` property set on thrown instances (used by {@link isNamedException}).
+* @param name - The `name` property set on thrown instances (used by `isNamedException`).
 * @param message - Printf-style template string for the error message.
 * @param code - Machine-readable error code stored on the static and instance `code` property.
 * @param status - HTTP status code associated with this exception class.
@@ -277,4 +278,4 @@ Object.defineProperty(exports, "validateOrThrow", {
 	}
 });
 
-//# sourceMappingURL=exceptions-CitH5wZI.js.map
+//# sourceMappingURL=exceptions-BRXrUKiW.js.map