@jxsuite/studio 6.1.0 → 6.1.2

package/src/editor/inline-format.ts

@@ -1,4 +1,5 @@
 /// <reference lib="dom" />
+/// <reference lib="dom.iterable" />
 /**
  * Inline-format.js — Inline formatting engine for contenteditable editing
  *
@@ -22,6 +23,25 @@ const FORMAT_TAGS = new Set([
   "span",
 ]);
 
+/** Whether `node` is an element. Decided by node type, so it holds for a node of any realm. */
+function isElementNode(node: Node): node is Element {
+  return node.nodeType === Node.ELEMENT_NODE;
+}
+
+/** Whether `node` is a text node (`CDATASection` has its own node type and is excluded). */
+function isTextNode(node: Node): node is Text {
+  return node.nodeType === Node.TEXT_NODE;
+}
+
+/** One edge-whitespace move {@link liftEdgeWhitespace} applies after its scan. */
+interface EdgeWhitespaceLift {
+  type: "lift-leading" | "lift-trailing";
+  el: Element;
+  /** The wrapper's first (leading) or last (trailing) child, whose edge whitespace moves out. */
+  text: Text;
+  ws: string;
+}
+
 /**
  * Check whether `tag` is currently active on both ends of the selection. Walks from anchor and
  * focus nodes up to editableRoot looking for the tag. Returns false if selection is outside
@@ -59,10 +79,7 @@ export function isTagActiveInSelection(tag: string, editableRoot: HTMLElement |
   const hasTag = (node: Node | null) => {
     let current = node;
     while (current && current !== editableRoot) {
-      if (
-        current.nodeType === Node.ELEMENT_NODE &&
-        (current as Element).tagName.toLowerCase() === tag
-      ) {
+      if (isElementNode(current) && current.tagName.toLowerCase() === tag) {
         return true;
       }
       current = current.parentNode;
@@ -121,20 +138,11 @@ export function toggleInlineFormat(tag: string, editableRoot: HTMLElement | null
  */
 function findIntersectingElements(tag: string, range: Range, root: HTMLElement) {
   const matches: Element[] = [];
-  const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, {
-    /**
-     * @param {Node} node
-     * @returns {number}
-     */
-    acceptNode(node: Node) {
-      if ((node as Element).tagName.toLowerCase() === tag && range.intersectsNode(node)) {
-        return NodeFilter.FILTER_ACCEPT;
-      }
-      return NodeFilter.FILTER_SKIP;
-    },
-  });
-  while (walker.nextNode()) {
-    matches.push(walker.currentNode as Element);
+  // Every descendant element, in document order: the same set a SHOW_ELEMENT tree walk visits.
+  for (const el of root.querySelectorAll("*")) {
+    if (el.tagName.toLowerCase() === tag && range.intersectsNode(el)) {
+      matches.push(el);
+    }
   }
   return matches;
 }
@@ -343,21 +351,19 @@ export function normalizeInlineContent(root: HTMLElement | null) {
  */
 function mergeAdjacentSiblings(root: HTMLElement) {
   let changed = false;
-  const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT);
   const toMerge: [Element, Element][] = [];
 
   // Collect pairs first to avoid mutation during walk
-  while (walker.nextNode()) {
-    const el = walker.currentNode as Element;
+  for (const el of root.querySelectorAll("*")) {
     const next = el.nextSibling;
     if (
       next &&
-      next.nodeType === Node.ELEMENT_NODE &&
-      (next as Element).tagName === el.tagName &&
+      isElementNode(next) &&
+      next.tagName === el.tagName &&
       FORMAT_TAGS.has(el.tagName.toLowerCase()) &&
-      attributesMatch(el, next as Element)
+      attributesMatch(el, next)
     ) {
-      toMerge.push([el, next as Element]);
+      toMerge.push([el, next]);
     }
   }
 
@@ -383,27 +389,31 @@ function mergeAdjacentSiblings(root: HTMLElement) {
  */
 function collapseRedundantNesting(root: HTMLElement) {
   let changed = false;
-  const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT);
   const toCollapse: Element[] = [];
 
-  while (walker.nextNode()) {
-    const el = walker.currentNode as Element;
+  for (const el of root.querySelectorAll("*")) {
     if (!FORMAT_TAGS.has(el.tagName.toLowerCase())) {
       continue;
     }
     // Check if only child is an element with the same tag
+    const only = el.firstChild;
     if (
       el.childNodes.length === 1 &&
-      el.firstChild !== null &&
-      el.firstChild.nodeType === Node.ELEMENT_NODE &&
-      (el.firstChild as Element).tagName === el.tagName
+      only !== null &&
+      isElementNode(only) &&
+      only.tagName === el.tagName
     ) {
       toCollapse.push(el);
     }
   }
 
   for (const el of toCollapse) {
-    const inner = el.firstChild as Element;
+    const inner = el.firstChild;
+    if (inner === null) {
+      /* Three or more nested identical wrappers: collapsing the outer pair moved this wrapper's only
+         child out, leaving it empty. That has always failed here, and is kept rather than changed. */
+      throw new TypeError("collapseRedundantNesting: an earlier collapse emptied this wrapper");
+    }
     // Replace outer with inner's children
     while (inner.firstChild) {
       inner.before(inner.firstChild);
@@ -422,11 +432,9 @@ function collapseRedundantNesting(root: HTMLElement) {
  */
 function removeEmptyInlines(root: HTMLElement) {
   let changed = false;
-  const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT);
   const toRemove: Element[] = [];
 
-  while (walker.nextNode()) {
-    const el = walker.currentNode as Element;
+  for (const el of root.querySelectorAll("*")) {
     if (!FORMAT_TAGS.has(el.tagName.toLowerCase())) {
       continue;
     }
@@ -451,12 +459,9 @@ function removeEmptyInlines(root: HTMLElement) {
  */
 function liftEdgeWhitespace(root: HTMLElement) {
   let changed = false;
-  const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT);
-  /** @type {{ type: string; el: Element; ws: string }[]} */
-  const ops = [];
+  const ops: EdgeWhitespaceLift[] = [];
 
-  while (walker.nextNode()) {
-    const el = walker.currentNode as Element;
+  for (const el of root.querySelectorAll("*")) {
     if (!FORMAT_TAGS.has(el.tagName.toLowerCase())) {
       continue;
     }
@@ -465,36 +470,36 @@ function liftEdgeWhitespace(root: HTMLElement) {
     }
 
     const first = el.firstChild;
-    if (first && first.nodeType === Node.TEXT_NODE) {
-      const text = first.textContent ?? "";
+    if (first && isTextNode(first)) {
+      const text = first.textContent;
       const m = text.match(/^(\s+)/);
       if (m && text.length > m[1]!.length) {
-        ops.push({ el, type: "lift-leading", ws: m[1]! });
+        ops.push({ el, text: first, type: "lift-leading", ws: m[1]! });
       }
     }
 
     const last = el.lastChild;
-    if (last && last.nodeType === Node.TEXT_NODE && last !== first) {
-      const text = last.textContent ?? "";
+    if (last && isTextNode(last) && last !== first) {
+      const text = last.textContent;
       const m = text.match(/(\s+)$/);
       if (m && text.length > m[1]!.length) {
-        ops.push({ el, type: "lift-trailing", ws: m[1]! });
+        ops.push({ el, text: last, type: "lift-trailing", ws: m[1]! });
       }
     }
   }
 
+  /* Each recorded text node is still its wrapper's edge child when its move runs: a move only edits
+     a text node's data and inserts a sibling OUTSIDE its own wrapper, and a wrapper whose edge child
+     is an element (the only place a nested move could insert) never recorded a move on that edge. */
   for (const op of ops) {
     if (op.type === "lift-leading") {
-      const firstChild = op.el.firstChild as Text;
-      firstChild.textContent = (firstChild.textContent ?? "").slice(op.ws.length);
+      op.text.textContent = op.text.textContent.slice(op.ws.length);
       op.el.parentNode?.insertBefore(document.createTextNode(op.ws), op.el);
-      changed = true;
-    } else if (op.type === "lift-trailing") {
-      const lastChild = op.el.lastChild as Text;
-      lastChild.textContent = (lastChild.textContent ?? "").slice(0, -op.ws.length);
+    } else {
+      op.text.textContent = op.text.textContent.slice(0, -op.ws.length);
       op.el.parentNode?.insertBefore(document.createTextNode(op.ws), op.el.nextSibling);
-      changed = true;
     }
+    changed = true;
   }
   return changed;
 }
@@ -508,11 +513,9 @@ function liftEdgeWhitespace(root: HTMLElement) {
  */
 function unwrapBareSpans(root: HTMLElement) {
   let changed = false;
-  const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT);
   const toUnwrap: Element[] = [];
 
-  while (walker.nextNode()) {
-    const el = walker.currentNode as Element;
+  for (const el of root.querySelectorAll("*")) {
     if (el.tagName.toLowerCase() !== "span") {
       continue;
     }

package/src/editor/inline-link.ts

@@ -8,32 +8,57 @@
  * it here (Phase 4b-2).
  *
  * `document.execCommand` is uncoverable under happy-dom (no implementation), so it is wrapped in a
- * one-line shim {@link exec} that the branch logic calls; tests stub `document.execCommand` and
- * assert at the stub level (documented as stub-level, not behavioral).
+ * one-line shim {@link execEditingCommand} that the branch logic calls; tests stub
+ * `document.execCommand` and assert at the stub level (documented as stub-level, not behavioral).
  */
 
 import { normalizeInlineContent } from "./inline-format";
 
-/** The one uncoverable call, isolated so the surrounding branch logic stays unit-testable. */
-const exec = (cmd: string, val?: string): boolean => document.execCommand(cmd, false, val);
+/**
+ * The one uncoverable call, isolated so the surrounding branch logic stays unit-testable, and the
+ * one place Studio reaches `document.execCommand`. It is deprecated, and NOT kept for the native
+ * undo stack: Studio owns history (`edit.undo` is forwarded out of the frame and a `historyUndo`
+ * `beforeinput` is rejected, studio.md §8.2.1). It is kept because it is the only script entry into
+ * the browser's editing engine, which a Range rewrite would not reproduce: `insertText` rebalances
+ * whitespace into ` ` runs (and back) around the caret, and `createLink` splits the anchor at
+ * inline-formatting boundaries it only partly covers.
+ */
+export const execEditingCommand = (cmd: string, val?: string): boolean =>
+  // oxlint-disable-next-line typescript/no-deprecated -- no successor API exists: execCommand is the only script entry into the browser's editing engine (whitespace rebalancing, anchor splitting), see the doc comment above
+  document.execCommand(cmd, false, val);
+
+/** The link the selection sits in, as the format toolbar's Link field shows it. */
+export interface LinkState {
+  /** Whether the selection anchor is inside an `<a>`. */
+  active: boolean;
+  /** The author-entered URL of that `<a>`, or null when there is none. */
+  href: string | null;
+}
+
+/**
+ * Whether `node` is an `<a>` element. Decided by node type and name rather than `instanceof`, so it
+ * holds for nodes of another realm; for an element, `nodeName` is its tag name.
+ */
+function isAnchorNode(node: Node): node is HTMLAnchorElement | SVGAElement {
+  return node.nodeType === Node.ELEMENT_NODE && node.nodeName.toLowerCase() === "a";
+}
 
 /**
  * Read the link state of the current selection relative to `root`: walk the selection's anchor node
  * up to `root` looking for an `<a>`. Returns the author-entered `href` attribute (NOT the resolved
  * `.href` property), so relative/templated URLs round-trip unchanged.
  */
-export function linkStateForSelection(root: HTMLElement): { active: boolean; href: string | null } {
+export function linkStateForSelection(root: HTMLElement): LinkState {
   const sel = window.getSelection();
   if (!sel || !sel.rangeCount) {
     return { active: false, href: null };
   }
   let node: Node | null = sel.anchorNode;
   while (node && node !== root) {
-    if (node.nodeType === Node.ELEMENT_NODE && (node as Element).tagName.toLowerCase() === "a") {
+    if (isAnchorNode(node)) {
       // Design/edit renders anchors de-linked, with the URL on `data-jx-href` — so the toolbar's
       // Link field must read that first or it shows an empty URL for every existing link.
-      const el = node as HTMLElement;
-      return { active: true, href: el.dataset.jxHref ?? el.getAttribute("href") };
+      return { active: true, href: node.dataset.jxHref ?? node.getAttribute("href") };
     }
     node = node.parentNode;
   }
@@ -44,17 +69,17 @@ export function linkStateForSelection(root: HTMLElement): { active: boolean; hre
  * Find the `<a>` that contains the selection anchor (up to `root`), if any.
  *
  * @param {HTMLElement} root
- * @returns {HTMLAnchorElement | null}
+ * @returns {HTMLAnchorElement | SVGAElement | null}
  */
-function anchorInSelection(root: HTMLElement): HTMLAnchorElement | null {
+function anchorInSelection(root: HTMLElement): HTMLAnchorElement | SVGAElement | null {
   const sel = window.getSelection();
   if (!sel || !sel.rangeCount) {
     return null;
   }
   let node: Node | null = sel.anchorNode;
   while (node && node !== root) {
-    if (node.nodeType === Node.ELEMENT_NODE && (node as Element).tagName.toLowerCase() === "a") {
-      return node as HTMLAnchorElement;
+    if (isAnchorNode(node)) {
+      return node;
     }
     node = node.parentNode;
   }
@@ -80,13 +105,13 @@ export function applyLink(root: HTMLElement, href: string | null): void {
       existing.replaceWith(frag);
     }
   } else if (href) {
-    exec("createLink", href);
+    execEditingCommand("createLink", href);
   }
   normalizeInlineContent(root);
 }
 
-/** Insert a `${token}` template expression at the caret inside `root` (joins the native undo stack). */
+/** Insert a `${token}` template expression at the caret inside `root`, through the editing engine. */
 export function insertTemplateToken(root: HTMLElement, token: string): void {
   root.focus();
-  exec("insertText", `\${${token}}`);
+  execEditingCommand("insertText", `\${${token}}`);
 }

package/src/editor/insert-zone-action.ts

@@ -22,7 +22,7 @@ export function runInsertZoneAction(btn: HTMLElement, zone: InsertZone): void {
   showSlashMenu(btn, "", {
     onSelect: (cmd) => {
       const def = defaultDef(cmd.tag);
-      const insertPath = zone.insertParentPath as JxPath;
+      const insertPath: JxPath = zone.insertParentPath;
       const idx = zone.index;
       const newPath = [...insertPath, "children", idx];
       transactDoc(activeTab.value, (t) => {

package/src/editor/merge-tags.ts

@@ -9,8 +9,10 @@
  * Pure and DOM-free: callers pass the data in, this returns plain descriptors.
  */
 
+import { isNonNullObject, isString } from "@jxsuite/schema/guards";
 import { defCategory } from "../panels/signals-panel";
 import { dataTypeLabel, unwrapSignal } from "../panels/data-explorer";
+import type { JsonPrimitive, JxStateDefinition } from "@jxsuite/schema/types";
 
 export interface MergeTag {
   /** Insertion token placed between `${` and `}`, e.g. `state.user.name`, `item.title`, `index`. */
@@ -23,20 +25,50 @@ export interface MergeTag {
   category: string;
 }
 
+/**
+ * A value in a live render scope, as far as the merge-tag walk reads it: document data, a handler,
+ * a pending (`undefined`) entry, or an object — a plain record, a fetched payload, a Vue ref —
+ * whose own keys hold further scope values.
+ */
+export type ScopeValue =
+  | JsonPrimitive
+  | undefined
+  | bigint
+  | symbol
+  | ((...args: never[]) => void)
+  | ScopeValue[]
+  | ScopeRecord;
+
+/** A render scope, or any object inside one, read key by key. */
+export interface ScopeRecord {
+  readonly [key: string]: ScopeValue;
+}
+
 /** Levels of nesting walked beneath each root name. */
 const DEPTH_CAP = 3;
 /** Maximum object keys enumerated per level (mirrors the data-explorer tree cap). */
 const BREADTH_CAP = 30;
 
+/** Whether a scope value is an object read by key: non-null, not an array, not a function. */
+function isScopeRecord(value: ScopeValue): value is ScopeRecord {
+  return isNonNullObject(value) && !Array.isArray(value);
+}
+
+/** The value behind a Vue ref, or the value itself. */
+function unwrapScopeValue(value: ScopeValue): ScopeValue {
+  /* SAFETY: unwrapSignal returns its argument unchanged, or a ref's `.value`; a ref is a scope record,
+     so its `.value` member is itself a scope value. */
+  return unwrapSignal(value) as ScopeValue;
+}
+
 /** Type label plus a short value preview for primitives. */
-function previewHint(value: unknown): string {
-  const v = unwrapSignal(value);
+function previewHint(value: ScopeValue): string {
+  const v = unwrapScopeValue(value);
   const typeLabel = dataTypeLabel(v);
-  if (v === null || v === undefined || typeof v === "object") {
+  if (v === null || v === undefined || isNonNullObject(v)) {
     return typeLabel; // Null / pending / Array(n) / {n}
   }
-  const text =
-    typeof v === "string" ? (v.length > 24 ? `"${v.slice(0, 24)}…"` : `"${v}"`) : String(v);
+  const text = isString(v) ? (v.length > 24 ? `"${v.slice(0, 24)}…"` : `"${v}"`) : String(v);
   return `${typeLabel} · ${text}`;
 }
 
@@ -44,25 +76,25 @@ function previewHint(value: unknown): string {
  * Walk a resolved value, appending nested-path tags to `out`. Arrays contribute a `.length` tag and
  * stop (index access is context-dependent); plain objects recurse up to the depth/breadth caps.
  */
-function walk(value: unknown, prefix: string, category: string, depth: number, out: MergeTag[]) {
+function walk(value: ScopeValue, prefix: string, category: string, depth: number, out: MergeTag[]) {
   if (depth >= DEPTH_CAP) {
     return;
   }
-  const v = unwrapSignal(value);
-  if (v === null || v === undefined || typeof v !== "object") {
-    return;
-  }
+  const v = unwrapScopeValue(value);
   if (Array.isArray(v)) {
     const token = `${prefix}.length`;
     out.push({ category, hint: `number · ${v.length}`, label: token, token });
     return;
   }
+  if (!isScopeRecord(v)) {
+    return;
+  }
   const keys = Object.keys(v).slice(0, BREADTH_CAP);
   for (const key of keys) {
     if (key.startsWith("$")) {
       continue; // Internal keys ($children, $ref, reactive plumbing) are not author-facing
     }
-    const childVal = (v as Record<string, unknown>)[key];
+    const childVal = v[key];
     const childPrefix = `${prefix}.${key}`;
     out.push({ category, hint: previewHint(childVal), label: childPrefix, token: childPrefix });
     walk(childVal, childPrefix, category, depth + 1, out);
@@ -80,9 +112,9 @@ function walk(value: unknown, prefix: string, category: string, depth: number, o
  *   carries a `$map` (repeater) context, `item` / `item.*` / `index` tags are appended.
  */
 export function buildMergeTags(
-  state: Record<string, unknown> | null | undefined,
-  scope: Record<string, unknown> | null | undefined,
-  localScope: Record<string, unknown> | null = null,
+  state: Readonly<Record<string, JxStateDefinition>> | null | undefined,
+  scope: ScopeRecord | null | undefined,
+  localScope: ScopeRecord | null = null,
 ): MergeTag[] {
   const out: MergeTag[] = [];
   const defs = state ?? {};
@@ -103,13 +135,20 @@ export function buildMergeTags(
   }
 
   if (localScope) {
-    const map = unwrapSignal(localScope.$map) as { item?: unknown; index?: unknown } | undefined;
-    if (map && typeof map === "object") {
-      out.push({ category: "repeater", hint: previewHint(map.item), label: "item", token: "item" });
-      walk(map.item, "item", "repeater", 0, out);
+    const map = unwrapScopeValue(localScope.$map);
+    if (isNonNullObject(map)) {
+      // An array `$map` has no `item` / `index` members, so it reads as an empty row.
+      const row = isScopeRecord(map) ? map : undefined;
+      out.push({
+        category: "repeater",
+        hint: previewHint(row?.item),
+        label: "item",
+        token: "item",
+      });
+      walk(row?.item, "item", "repeater", 0, out);
       out.push({
         category: "repeater",
-        hint: previewHint(map.index),
+        hint: previewHint(row?.index),
         label: "index",
         token: "index",
       });

package/src/editor/repeater-scope.ts

@@ -12,12 +12,22 @@
  * Pure and DOM-free: deps limited to `@jxsuite/schema` guards/types + {@link getNodeAtPath}.
  */
 
-import { isRef } from "@jxsuite/schema/guards";
-import { getNodeAtPath } from "../state";
+import { getNodeAtPath } from "@jxsuite/schema/doc-ops";
+import {
+  isJsonObject,
+  isMappedArray,
+  isNonNullObject,
+  isRef,
+  isString,
+} from "@jxsuite/schema/guards";
 
 import type { JxPath } from "../state";
-import type { ContentSectionEntry } from "../types";
-import type { JxMappedArray, JxMutableNode, ProjectConfig } from "@jxsuite/schema/types";
+import type {
+  JxMappedArray,
+  JxMutableNode,
+  JxStateDefinition,
+  ProjectConfig,
+} from "@jxsuite/schema/types";
 
 /** Cap on how many inferred/declared fields we enumerate (mirrors merge-tags BREADTH_CAP breadth). */
 const FIELD_CAP = 50;
@@ -44,18 +54,16 @@ export function findEnclosingRepeater(
   if (mapIdx <= 0) {
     return null;
   }
-  const node = getNodeAtPath(doc, path.slice(0, mapIdx)) as
-    | (Record<string, unknown> & JxMappedArray)
-    | undefined;
-  return node && node.$prototype === "Array" ? (node as JxMappedArray) : null;
+  const node = getNodeAtPath(doc, path.slice(0, mapIdx));
+  return isMappedArray(node) ? node : null;
 }
 
 /** Strip a `#/state/<name>` JSON-Pointer ref to its bare state name (null when it is not one). */
-function refToStateName(ref: unknown): string | null {
-  if (!isRef(ref)) {
+function refToStateName(binding: JxMappedArray["items"]): string | null {
+  if (!isRef(binding)) {
     return null;
   }
-  const { $ref: target } = ref;
+  const { $ref: target } = binding;
   return target.startsWith("#/state/") ? target.slice("#/state/".length) : null;
 }
 
@@ -85,25 +93,28 @@ function safeFields(names: string[]): string[] {
  */
 export function resolveRepeaterItemFields(
   arrayNode: JxMappedArray,
-  state: Record<string, unknown> | null | undefined,
+  state: Readonly<Record<string, JxStateDefinition>> | null | undefined,
   projectConfig: ProjectConfig | null | undefined,
 ): string[] {
   const base = ["item", "index"];
-  const { items } = arrayNode as { items?: unknown };
+  const { items } = arrayNode;
   const defs = state ?? {};
 
   const stateName = refToStateName(items);
   if (stateName) {
-    const def = defs[stateName] as Record<string, unknown> | undefined;
-    if (def && typeof def === "object") {
+    const def = defs[stateName];
+    if (isJsonObject(def)) {
       // (a) Content collection — `{ contentType: "<name>" }`. Import-aliased `$prototype` still
       // Matches because we detect on the `contentType` string, not the prototype name.
-      if (typeof def.contentType === "string") {
-        const content = (projectConfig?.content ?? {}) as Record<string, ContentSectionEntry>;
-        const ct = content[def.contentType];
-        const props = ct?.schema?.properties;
+      if (isString(def.contentType)) {
+        /* The `content` section is contributed by an extension and absorbed by the project
+           config's index signature, so each level is checked before it is read. */
+        const content = projectConfig?.content;
+        const ct = isJsonObject(content) ? content[def.contentType] : undefined;
+        const ctSchema = isJsonObject(ct) ? ct.schema : undefined;
+        const props = isJsonObject(ctSchema) ? ctSchema.properties : undefined;
         const out = [...base, "item.id", "item.body"];
-        if (props && typeof props === "object") {
+        if (isNonNullObject(props)) {
           for (const f of safeFields(Object.keys(props))) {
             out.push(`item.data.${f}`);
           }
@@ -112,14 +123,14 @@ export function resolveRepeaterItemFields(
       }
 
       // (b) State array — declared object item-schema, or inferred from a sample default[0].
-      const itemsSchema = def.items as Record<string, unknown> | undefined;
-      const declared = itemsSchema?.properties as Record<string, unknown> | undefined;
-      if (declared && typeof declared === "object") {
+      const itemsSchema = def.items;
+      const declared = isJsonObject(itemsSchema) ? itemsSchema.properties : undefined;
+      if (isNonNullObject(declared)) {
         return [...base, ...safeFields(Object.keys(declared)).map((f) => `item.${f}`)];
       }
-      const defaults = def.default as unknown[] | undefined;
-      const sample: unknown = Array.isArray(defaults) ? defaults[0] : undefined;
-      if (sample && typeof sample === "object" && !Array.isArray(sample)) {
+      const defaults = def.default;
+      const sample = Array.isArray(defaults) ? defaults[0] : undefined;
+      if (isJsonObject(sample)) {
         return [...base, ...safeFields(Object.keys(sample)).map((f) => `item.${f}`)];
       }
     }
@@ -128,8 +139,8 @@ export function resolveRepeaterItemFields(
 
   // (c) Inline literal array — infer fields from the first object element.
   if (Array.isArray(items)) {
-    const [first] = items as unknown[];
-    if (first && typeof first === "object" && !Array.isArray(first)) {
+    const [first] = items;
+    if (isJsonObject(first)) {
       return [...base, ...safeFields(Object.keys(first)).map((f) => `item.${f}`)];
     }
   }