@json-layout/core 2.9.0 → 2.9.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@json-layout/core",
-  "version": "2.9.0",
+  "version": "2.9.1",
   "description": "Compilation and state management utilities for JSON Layout.",
   "type": "module",
   "exports": {

package/src/webmcp/project.js

@@ -95,15 +95,20 @@ export function helpToText (html) {
 }
 
 /**
- * Which nodes are currently rendered, by path. A node hidden by an `if` condition stays
- * in the tree as comp "none", so what a write changes is visibility rather than the set
- * of paths — comparing paths alone would report nothing.
+ * Which nodes are currently rendered, by path. A node hidden by a layout `if` stays in
+ * the tree as comp "none", so what a write changes there is visibility rather than the
+ * set of paths — comparing paths alone would report nothing. A node governed by a schema
+ * if/then is the other way round: it is absent until the condition holds, so the set of
+ * paths is all there is to compare. Recording both facts lets one diff serve both.
  * @param {import('../state/types.js').StateNode} node
- * @param {Map<string, string>} [into]
- * @returns {Map<string, string>}
+ * @param {Map<string, {comp: string, owns: boolean}>} [into]
+ * @returns {Map<string, {comp: string, owns: boolean}>}
  */
 export function visibilitySnapshot (node, into = new Map()) {
-  if (node.fullKey !== undefined) into.set(node.fullKey, node.layout?.comp)
+  // `owns` separates a field from the wrappers around it. A condition turning true brings
+  // its `$then` section along with the fields inside it, and naming the section among the
+  // things that "became available" would point the agent at a path it cannot write.
+  if (node.fullKey !== undefined) into.set(node.fullKey, { comp: node.layout?.comp, owns: node.dataPath !== node.parentDataPath })
   for (const child of node.children ?? []) visibilitySnapshot(child, into)
   return into
 }
@@ -111,24 +116,40 @@ export function visibilitySnapshot (node, into = new Map()) {
 /**
  * What a write turned visible or invisible.
  *
- * Only paths present in both snapshots count. Activating a variant replaces one branch
- * with another, so its nodes are new paths rather than nodes that changed visibility —
- * setFieldValue already lists the activated branch, and counting them here would print
- * the same subtree twice.
- * @param {Map<string, string>} before
- * @param {Map<string, string>} after
+ * A field can arrive two ways: a layout `if` toggles a node that already exists between
+ * comp "none" and its real component, while a schema-level if/then has no node at all
+ * until the condition holds and then creates one. Both are the same event to an agent —
+ * something it must now fill that it could not before — so both count.
+ *
+ * `activated` is the variant selector a write just switched, if any. Activating a variant
+ * replaces a whole branch, and setFieldValue already lists the branch it activated;
+ * counting those nodes here too would print the same subtree twice.
+ * @param {Map<string, {comp: string, owns: boolean}>} before
+ * @param {Map<string, {comp: string, owns: boolean}>} after
+ * @param {string} [activated] - fullKey of a variant selector whose subtree is reported elsewhere
  * @returns {{ revealed: string[], hidden: string[] }}
  */
-export function diffVisibility (before, after) {
+export function diffVisibility (before, after, activated) {
   /** @type {string[]} */
   const revealed = []
   /** @type {string[]} */
   const hidden = []
-  for (const [path, comp] of after) {
-    if (!before.has(path)) continue
+  /** @param {string} path */
+  const reportedElsewhere = (path) => activated !== undefined && (path === activated || path.startsWith(activated + '/'))
+  for (const [path, node] of after) {
+    if (reportedElsewhere(path)) continue
     const was = before.get(path)
-    if (was === 'none' && comp !== 'none') revealed.push(path)
-    else if (was !== 'none' && comp === 'none') hidden.push(path)
+    if (was === undefined) {
+      if (node.comp !== 'none' && node.owns) revealed.push(path)
+    } else if (was.comp === 'none' && node.comp !== 'none') revealed.push(path)
+    else if (was.comp !== 'none' && node.comp === 'none') hidden.push(path)
+  }
+  // A condition turning false takes its subtree away entirely rather than hiding it. That
+  // is worth one line: an agent holding a path from an earlier describeState would
+  // otherwise keep trying to write somewhere that no longer exists.
+  for (const [path, node] of before) {
+    if (after.has(path) || reportedElsewhere(path)) continue
+    if (node.comp !== 'none' && node.owns) hidden.push(path)
   }
   return { revealed, hidden }
 }
@@ -441,16 +462,25 @@ export function projectNodeToMarkdown (node, statefulLayout, depth = 0, errorsBy
   // variants list
   if (node.layout.comp === 'one-of-select' && Array.isArray(layout.oneOfItems)) {
     const variants = layout.oneOfItems.filter((item) => !item.header)
+    // Which branch is live was only ever implied, by the index in the path of the section
+    // printed underneath. That reads as "a branch exists" rather than "this one is
+    // active", and an agent that cannot tell the two apart cannot tell a switch that
+    // worked from one that did nothing — which is the whole question it asks a variant
+    // selector. The activated branch is always this node's first child.
+    const activeKey = node.children?.[0]?.key
     const listedAt = variantsMemo?.listedAt(node.skeleton.pointer)
     if (listedAt === undefined) {
       variantsMemo?.record(node.skeleton.pointer, path)
       for (const v of variants) {
-        lines.push(`${indent}  - variant ${v.key}: ${v.title}`)
+        lines.push(`${indent}  - variant ${v.key}: ${v.title}${v.key === activeKey ? ' (active)' : ''}`)
       }
     } else {
       // a recursive schema reaches the same union at many paths; the list is a constant,
-      // so name where it was given rather than repeat it
-      lines.push(`${indent}  - ${variants.length} variants, the same list already given for ${listedAt} — call describeState on ${path} to see them again`)
+      // so name where it was given rather than repeat it — but which branch is active is
+      // this node's own, so it still has to be said here
+      const active = variants.find((v) => v.key === activeKey)
+      const activeLabel = active ? ` (variant ${active.key}: ${active.title} active)` : ''
+      lines.push(`${indent}  - ${variants.length} variants${activeLabel}, the same list already given for ${listedAt} — call describeState on ${path} to see them again`)
     }
   }
 
@@ -622,6 +652,35 @@ function dataPointerOf (error) {
   return original?.instancePath ?? ''
 }
 
+/**
+ * Whether an error belongs to a branch of a union the form is actually showing.
+ *
+ * ajv validates every branch of a `oneOf` and reports the failures of all of them, so
+ * while the chosen branch is still incomplete the losing branches complain too. Those
+ * complaints name properties of a shape that was not chosen: there is no node for them,
+ * no way to write them and no way to clear them. The state tree already draws this line —
+ * it matches an error to a node by schema pointer, so only the active branch's errors
+ * ever land on one — and this keeps the raw list that is appended afterwards to the same
+ * line rather than undoing the work.
+ *
+ * The test is per `oneOf` crossed on the way down, not on the error's path as a whole: an
+ * error below an unhydrated list item has no node either, and that one must survive.
+ * @param {any} error
+ * @param {Set<string>} renderedPointers - skeleton pointers of the nodes the form has built
+ * @returns {boolean}
+ */
+function isRenderedBranch (error, renderedPointers) {
+  for (const schemaPath of [error?.schemaPath, error?.params?.errors?.[0]?.schemaPath]) {
+    if (typeof schemaPath !== 'string') continue
+    const branches = /\/oneOf\/\d+/g
+    let match
+    while ((match = branches.exec(schemaPath)) !== null) {
+      if (!renderedPointers.has(schemaPath.slice(0, match.index + match[0].length))) return false
+    }
+  }
+  return true
+}
+
 /**
  * Errors of the whole form, each named by the location it actually applies to.
  *
@@ -639,9 +698,12 @@ function dataPointerOf (error) {
 export function collectErrors (statefulLayout) {
   /** @type {Array<{fullKey: string, dataPath: string, message: string}>} */
   const nodeErrors = []
+  /** @type {Set<string>} */
+  const renderedPointers = new Set()
   /** @param {import('../state/types.js').StateNode} node */
   const recurse = (node) => {
     if (node.error) nodeErrors.push({ fullKey: node.fullKey, dataPath: node.dataPath, message: node.error })
+    if (node.skeleton?.pointer) renderedPointers.add(node.skeleton.pointer)
     // all children, not visibleChildren: in "menu"/"dialog" list edit modes the two
     // occurrences of an activated item do not carry the same errors, and deduplicating
     // here silently drops them (verified: 2 errors became 0).
@@ -651,6 +713,7 @@ export function collectErrors (statefulLayout) {
 
   const named = new Set(nodeErrors.map((e) => e.dataPath))
   const unnamed = statefulLayout.validationErrors
+    .filter((error) => isRenderedBranch(error, renderedPointers))
     .map((error) => ({ pointer: dataPointerOf(error), message: error.message ?? 'invalid' }))
     .filter((error) => !named.has(error.pointer))
 

package/src/webmcp/tools/set-field-value.js

@@ -31,6 +31,31 @@ export function getDescription (dataTitle) {
   return `Set the value of a specific field of "${dataTitle}" by path. To switch a variant selector, set value to the desired variant index (shown in describeState); the answer then lists the fields of the branch it activated. The returned errors are scoped to the modified field.`
 }
 
+/**
+ * The variant index an agent meant, from either spelling of it. A tool call is JSON and a
+ * model writes 0 and "0" interchangeably; both name the same branch.
+ * @param {unknown} value
+ * @returns {number|undefined}
+ */
+function variantIndex (value) {
+  if (typeof value === 'number') return Number.isInteger(value) ? value : undefined
+  if (typeof value === 'string' && /^\s*\d+\s*$/.test(value)) return Number(value)
+  return undefined
+}
+
+/**
+ * The branches a variant selector offers, as describeState lists them, so that refusing a
+ * call can name what to write instead of only what was wrong.
+ * @param {import('../../state/types.js').StateNode} node
+ * @returns {Array<{key: number, title: string}>|undefined}
+ */
+function listVariants (node) {
+  const oneOfItems = /** @type {Array<{header?: boolean, key: number, title: string}>|undefined} */(
+    /** @type {Record<string, unknown>} */(node.layout).oneOfItems
+  )
+  return Array.isArray(oneOfItems) ? oneOfItems.filter((item) => !item.header) : undefined
+}
+
 /**
  * @param {import('../../state/index.js').StatefulLayout} statefulLayout
  * @param {{ path: string, value?: unknown, suggestionIndex?: number }} args
@@ -64,9 +89,23 @@ export function execute (statefulLayout, args, store, variantsMemo) {
   const visibleBefore = visibilitySnapshot(statefulLayout.stateTree.root)
 
   let activating = false
-  if (node.key === '$oneOf' && typeof value === 'number') {
+  if (node.key === '$oneOf') {
+    // A variant selector holds no data of its own — its value IS the object around it —
+    // so anything that is not an index does not land on the selector, it is merged into
+    // that object: the string "0" became {"0":"0"} beside the branch's own properties.
+    // The guard used to demand a number and let everything else through to that write,
+    // which reported no error and left the form valid. Models emit tool arguments as
+    // JSON and write an index as "0" at least as readily as 0, so the common spelling of
+    // a correct call was silently doing nothing at all — app-chloropleth-map's agent
+    // repeated it fifteen times, each answer as reassuring as the last.
+    const index = variantIndex(value)
+    const variants = listVariants(node)
+    if (index === undefined || (variants && !variants.some((v) => v.key === index))) {
+      const listed = variants?.map((v) => `variant ${v.key}: ${v.title}`).join(', ')
+      throw new Error(`"${args.path}" is a variant selector: its value is the index of the branch to activate${listed ? `, one of ${listed}` : ''}.`)
+    }
     activating = true
-    statefulLayout.activateItem(node, value)
+    statefulLayout.activateItem(node, index)
   } else {
     statefulLayout.input(node, value)
     statefulLayout.blur(node)
@@ -80,7 +119,7 @@ export function execute (statefulLayout, args, store, variantsMemo) {
   // was written leaves the agent knowing a branch appeared but not what is in it. This
   // mirrors what editArray already does for an item it activates.
   const activated = activating ? (updatedNode || node).children?.[0] : undefined
-  const visibility = diffVisibility(visibleBefore, visibilitySnapshot(statefulLayout.stateTree.root))
+  const visibility = diffVisibility(visibleBefore, visibilitySnapshot(statefulLayout.stateTree.root), activating ? args.path : undefined)
 
   return {
     valid: statefulLayout.valid,

package/types/webmcp/project.d.ts

@@ -8,26 +8,45 @@
  */
 export function helpToText(html: string): string;
 /**
- * Which nodes are currently rendered, by path. A node hidden by an `if` condition stays
- * in the tree as comp "none", so what a write changes is visibility rather than the set
- * of paths — comparing paths alone would report nothing.
+ * Which nodes are currently rendered, by path. A node hidden by a layout `if` stays in
+ * the tree as comp "none", so what a write changes there is visibility rather than the
+ * set of paths — comparing paths alone would report nothing. A node governed by a schema
+ * if/then is the other way round: it is absent until the condition holds, so the set of
+ * paths is all there is to compare. Recording both facts lets one diff serve both.
  * @param {import('../state/types.js').StateNode} node
- * @param {Map<string, string>} [into]
- * @returns {Map<string, string>}
- */
-export function visibilitySnapshot(node: import("../state/types.js").StateNode, into?: Map<string, string>): Map<string, string>;
+ * @param {Map<string, {comp: string, owns: boolean}>} [into]
+ * @returns {Map<string, {comp: string, owns: boolean}>}
+ */
+export function visibilitySnapshot(node: import("../state/types.js").StateNode, into?: Map<string, {
+    comp: string;
+    owns: boolean;
+}>): Map<string, {
+    comp: string;
+    owns: boolean;
+}>;
 /**
  * What a write turned visible or invisible.
  *
- * Only paths present in both snapshots count. Activating a variant replaces one branch
- * with another, so its nodes are new paths rather than nodes that changed visibility —
- * setFieldValue already lists the activated branch, and counting them here would print
- * the same subtree twice.
- * @param {Map<string, string>} before
- * @param {Map<string, string>} after
+ * A field can arrive two ways: a layout `if` toggles a node that already exists between
+ * comp "none" and its real component, while a schema-level if/then has no node at all
+ * until the condition holds and then creates one. Both are the same event to an agent —
+ * something it must now fill that it could not before — so both count.
+ *
+ * `activated` is the variant selector a write just switched, if any. Activating a variant
+ * replaces a whole branch, and setFieldValue already lists the branch it activated;
+ * counting those nodes here too would print the same subtree twice.
+ * @param {Map<string, {comp: string, owns: boolean}>} before
+ * @param {Map<string, {comp: string, owns: boolean}>} after
+ * @param {string} [activated] - fullKey of a variant selector whose subtree is reported elsewhere
  * @returns {{ revealed: string[], hidden: string[] }}
  */
-export function diffVisibility(before: Map<string, string>, after: Map<string, string>): {
+export function diffVisibility(before: Map<string, {
+    comp: string;
+    owns: boolean;
+}>, after: Map<string, {
+    comp: string;
+    owns: boolean;
+}>, activated?: string): {
     revealed: string[];
     hidden: string[];
 };

package/types/webmcp/project.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../src/webmcp/project.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../src/webmcp/project.js"],"names":[],"mappings":"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"}

package/types/webmcp/tools/set-field-value.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"set-field-value.d.ts","sourceRoot":"","sources":["../../../src/webmcp/tools/set-field-value.js"],"names":[],"mappings":"AAyBA;;;GAGG;AACH,0CAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;GAOG;AACH,wCAPW,OAAO,sBAAsB,EAAE,cAAc,QAC7C;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,eAAe,CAAC,EAAE,MAAM,CAAA;CAAE,UAC3D,OAAO,yBAAyB,EAAE,gBAAgB,iBAClD,OAAO,qBAAqB,EAAE,YAAY,GAExC;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC;IAAC,MAAM,EAAE,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE;QAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE,CAAA;CAAE,CAqDpO;;;;;;;;;;;;;;;;;;;;;;mCAxFkH,eAAe"}
+{"version":3,"file":"set-field-value.d.ts","sourceRoot":"","sources":["../../../src/webmcp/tools/set-field-value.js"],"names":[],"mappings":"AAyBA;;;GAGG;AACH,0CAHW,MAAM,GACJ,MAAM,CAIlB;AA2BD;;;;;;;GAOG;AACH,wCAPW,OAAO,sBAAsB,EAAE,cAAc,QAC7C;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,eAAe,CAAC,EAAE,MAAM,CAAA;CAAE,UAC3D,OAAO,yBAAyB,EAAE,gBAAgB,iBAClD,OAAO,qBAAqB,EAAE,YAAY,GAExC;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC;IAAC,MAAM,EAAE,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE;QAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE,CAAA;CAAE,CAmEpO;;;;;;;;;;;;;;;;;;;;;;mCA/HkH,eAAe"}