@script-it/json-views-core 0.1.0-beta.1 → 2026.10.25

package/README.md

@@ -51,6 +51,8 @@ The compiler returns the untouched effective `metadata`, its `metadataSource` (`
 
 Only integer version `1` is supported. Other positive integer versions produce `unsupported-metadata-version`; malformed annotations produce `invalid-metadata`. The raw future metadata is retained for round trips and source editing. Consumers must not overwrite it with inferred metadata or version 1 settings.
 
+Checking every document value against the schema is most of the compile time on large documents. Callers that only need the compiled schema and views, such as a route or settings panel, can pass `{ validateValues: false }`: the schema, views, and every other diagnostic are identical, and value diagnostics are omitted.
+
 ### Paths and precedence
 
 All paths start at `$`. Supported segments are `.property`, `['quoted property']`, `[0]`, and `[*]`. Quoted properties support single-quote, backslash, slash, control-character, and `\uXXXX` escapes. Array indices are nonnegative safe integers without leading zeros. A numeric-looking object key is a string property, such as `$['0']`; it is different from `$[0]`.
@@ -161,7 +163,7 @@ Patching helpers preserve unrelated bytes. The agent-facing mutation API accepts
 
 Compiled metadata includes the root and each view's `value` snapshot for direct rendering. `applyJsonViewViewRows`, `projectJsonViewCollection`, and `resolveJsonViewRowPath` resolve against their explicit current-root argument. `getJsonViewViewRows(view, root)` does the same; `getJsonViewViewRows(view)` intentionally reads the compiled snapshot. Recompile when annotations or registry behavior change, or to refresh diagnostics and inferred options for a new document revision.
 
-The synchronous compiler and scanner have no universal document-size guarantee. Table virtualization limits mounted rows, not parsing, validation, projection, or Kanban work. Source revision caching avoids unnecessary repeat work; applications handling very large documents should perform compilation/inspection in a worker and choose their own measured size budgets. The test workload covers 1,000 independent edits within a 10,000-row document, and comparator/adversarial-pattern regressions are retained in the core suite.
+The synchronous compiler and scanner have no universal document-size guarantee. Table virtualization limits mounted rows, not parsing, validation, projection, or Kanban work. `inspectJsonSource` keeps the diagnostics of the most recently inspected text, so hosts that inspect one revision several times pay for one scan; applications handling very large documents should perform compilation/inspection in a worker and choose their own measured size budgets. The test workload covers 1,000 independent edits within a 10,000-row document, and comparator/adversarial-pattern regressions are retained in the core suite.
 
 ### Host acknowledgements and reloads
 

package/dist/formats/json-format.js

@@ -48,62 +48,92 @@ export function jsonFormatForSource(source) {
 export function jsonFormatForRoot(root) {
     return Array.isArray(root) ? jsonArrayFormat : jsonObjectFormat;
 }
+// Outside strings, valid JSON only contains these four whitespace characters.
+function isJsonWhitespace(code) {
+    return code === 0x20 || code === 0x0a || code === 0x0d || code === 0x09;
+}
+function isStructural(code) {
+    return code === 0x22 || code === 0x7b || code === 0x5b || code === 0x7d || code === 0x5d || code === 0x2c || code === 0x3a;
+}
 /** Pretty-print JSON without changing numeric spelling, duplicate keys, or string contents. */
 export function formatJsonSource(source) {
     assertJsonDepth(JSON.parse(source));
-    let formatted = '';
-    let depth = 0;
-    let escaped = false;
-    let inString = false;
+    const parts = [];
     const expandedContainers = [];
-    const indentation = () => '  '.repeat(depth);
-    for (let index = 0; index < source.length; index += 1) {
-        const character = source[index];
-        if (inString) {
-            formatted += character;
-            if (escaped)
-                escaped = false;
-            else if (character === '\\')
-                escaped = true;
-            else if (character === '"')
-                inString = false;
+    const length = source.length;
+    let depth = 0;
+    let indentation = '';
+    const indent = (next) => {
+        depth = next;
+        indentation = '  '.repeat(depth);
+    };
+    let index = 0;
+    while (index < length) {
+        const code = source.charCodeAt(index);
+        if (code === 0x22) {
+            // Strings are copied whole, escapes included.
+            let end = index + 1;
+            while (end < length) {
+                const inner = source.charCodeAt(end);
+                end += 1;
+                if (inner === 0x5c)
+                    end += 1;
+                else if (inner === 0x22)
+                    break;
+            }
+            parts.push(source.slice(index, end));
+            index = end;
             continue;
         }
-        if (/\s/.test(character))
-            continue;
-        if (character === '"') {
-            inString = true;
-            formatted += character;
+        if (isJsonWhitespace(code)) {
+            index += 1;
             continue;
         }
-        if (character === '{' || character === '[') {
-            const closingCharacter = character === '{' ? '}' : ']';
+        if (code === 0x7b || code === 0x5b) {
+            const closing = code === 0x7b ? 0x7d : 0x5d;
             let nextIndex = index + 1;
-            while (nextIndex < source.length && /\s/.test(source[nextIndex]))
+            while (nextIndex < length && isJsonWhitespace(source.charCodeAt(nextIndex)))
                 nextIndex += 1;
-            const expanded = source[nextIndex] !== closingCharacter;
+            const expanded = source.charCodeAt(nextIndex) !== closing;
             expandedContainers.push(expanded);
-            formatted += character;
+            parts.push(source[index]);
             if (expanded) {
-                depth += 1;
-                formatted += `\n${indentation()}`;
+                indent(depth + 1);
+                parts.push(`\n${indentation}`);
             }
+            index += 1;
             continue;
         }
-        if (character === '}' || character === ']') {
+        if (code === 0x7d || code === 0x5d) {
             const expanded = expandedContainers.pop() ?? false;
             if (expanded) {
-                depth -= 1;
-                formatted += `\n${indentation()}`;
+                indent(depth - 1);
+                parts.push(`\n${indentation}`);
             }
-            formatted += character;
+            parts.push(source[index]);
+            index += 1;
             continue;
         }
-        if (character === ',') {
-            formatted += `,\n${indentation()}`;
+        if (code === 0x2c) {
+            parts.push(`,\n${indentation}`);
+            index += 1;
             continue;
         }
-        formatted += character === ':' ? ': ' : character;
+        if (code === 0x3a) {
+            parts.push(': ');
+            index += 1;
+            continue;
+        }
+        // Numbers and literals are copied as one run.
+        let end = index + 1;
+        while (end < length) {
+            const inner = source.charCodeAt(end);
+            if (isStructural(inner) || isJsonWhitespace(inner))
+                break;
+            end += 1;
+        }
+        parts.push(source.slice(index, end));
+        index = end;
     }
-    return formatted;
+    return parts.join('');
 }

package/dist/json-source-patcher.js

@@ -15,6 +15,25 @@ function assertSameEditableAtomicType(current, next, path) {
         throw new TypeError(`Replacement at ${describeValuePath(path)} must keep type ${currentType}`);
     }
 }
+// Character codes the scanner dispatches on. The text is already valid JSON.
+const QUOTE = 0x22;
+const COMMA = 0x2c;
+const MINUS = 0x2d;
+const COLON = 0x3a;
+const OPEN_BRACKET = 0x5b;
+const BACKSLASH = 0x5c;
+const CLOSE_BRACKET = 0x5d;
+const OPEN_BRACE = 0x7b;
+const CLOSE_BRACE = 0x7d;
+function isJsonWhitespace(code) {
+    return code === 0x20 || code === 0x0a || code === 0x0d || code === 0x09;
+}
+function isDigit(code) {
+    return code >= 0x30 && code <= 0x39;
+}
+function isNumberCharacter(code) {
+    return isDigit(code) || code === 0x2e || code === MINUS || code === 0x2b || code === 0x65 || code === 0x45;
+}
 class JsonSourceScanner {
     index = 0;
     source;
@@ -23,6 +42,7 @@ class JsonSourceScanner {
     }
     parse() {
         // Callers validate once with JSON.parse before scanning source spans.
+        const source = this.source;
         const root = this.parseValue();
         const frames = [];
         const push = (node, property) => {
@@ -37,8 +57,8 @@ class JsonSourceScanner {
             const frame = frames[frames.length - 1];
             const node = frame.node;
             this.skipWhitespace();
-            const close = node.kind === 'array' ? ']' : '}';
-            if (this.source[this.index] === close) {
+            const close = node.kind === 'array' ? CLOSE_BRACKET : CLOSE_BRACE;
+            if (source.charCodeAt(this.index) === close) {
                 node.end = ++this.index;
                 if (frame.property)
                     frame.property.end = node.end;
@@ -46,7 +66,7 @@ class JsonSourceScanner {
                 continue;
             }
             if (frame.afterValue) {
-                if (this.source[this.index++] !== ',')
+                if (source.charCodeAt(this.index++) !== COMMA)
                     throw new SyntaxError('Expected comma');
                 this.skipWhitespace();
             }
@@ -58,10 +78,12 @@ class JsonSourceScanner {
             }
             else {
                 const start = this.index;
-                this.scanString();
-                const key = JSON.parse(this.source.slice(start, this.index));
+                // A key without escapes is its own text; JSON.parse decodes the rest.
+                const key = this.scanString()
+                    ? JSON.parse(source.slice(start, this.index))
+                    : source.slice(start + 1, this.index - 1);
                 this.skipWhitespace();
-                if (this.source[this.index++] !== ':')
+                if (source.charCodeAt(this.index++) !== COLON)
                     throw new SyntaxError('Expected colon');
                 const value = this.parseValue();
                 const property = { key, start, end: value.end, value };
@@ -71,50 +93,61 @@ class JsonSourceScanner {
             }
         }
         this.skipWhitespace();
-        if (this.index !== this.source.length)
+        if (this.index !== source.length)
             throw new SyntaxError('Unexpected content after JSON value');
         return root;
     }
     skipWhitespace() {
-        while (this.index < this.source.length && /[\t\n\r ]/.test(this.source[this.index]))
-            this.index++;
+        const source = this.source;
+        let index = this.index;
+        while (index < source.length && isJsonWhitespace(source.charCodeAt(index)))
+            index += 1;
+        this.index = index;
     }
     parseValue() {
         this.skipWhitespace();
         const start = this.index;
-        const token = this.source[this.index];
-        if (token === '{') {
-            this.index++;
+        const code = this.source.charCodeAt(start);
+        if (code === OPEN_BRACE) {
+            this.index += 1;
             return { start, end: this.index, kind: 'object', properties: [], propertyIndex: new Map() };
         }
-        if (token === '[') {
-            this.index++;
+        if (code === OPEN_BRACKET) {
+            this.index += 1;
             return { start, end: this.index, kind: 'array', items: [] };
         }
-        if (token === '"') {
+        if (code === QUOTE) {
             this.scanString();
             return { start, end: this.index, kind: 'atomic' };
         }
-        if (token === 't')
+        if (code === 0x74)
             return this.scanLiteral(start, 'true');
-        if (token === 'f')
+        if (code === 0x66)
             return this.scanLiteral(start, 'false');
-        if (token === 'n')
+        if (code === 0x6e)
             return this.scanLiteral(start, 'null');
         return this.scanNumber(start);
     }
+    /** Moves past the closing quote and reports whether the string used escapes. */
     scanString() {
-        if (this.source[this.index] !== '"')
+        const source = this.source;
+        if (source.charCodeAt(this.index) !== QUOTE)
             throw new SyntaxError('Expected JSON string');
-        this.index++;
-        while (this.index < this.source.length) {
-            const token = this.source[this.index];
-            this.index++;
-            if (token === '"')
-                return;
-            if (token === '\\')
-                this.index++;
+        let index = this.index + 1;
+        let escaped = false;
+        while (index < source.length) {
+            const code = source.charCodeAt(index);
+            index += 1;
+            if (code === QUOTE) {
+                this.index = index;
+                return escaped;
+            }
+            if (code === BACKSLASH) {
+                escaped = true;
+                index += 1;
+            }
         }
+        this.index = index;
         throw new SyntaxError('Unterminated JSON string');
     }
     scanLiteral(start, literal) {
@@ -122,11 +155,14 @@ class JsonSourceScanner {
         return { start, end: this.index, kind: 'atomic' };
     }
     scanNumber(start) {
-        while (this.index < this.source.length && /[0-9eE+.-]/.test(this.source[this.index]))
-            this.index++;
-        if (this.index === start)
+        const source = this.source;
+        let index = start;
+        while (index < source.length && isNumberCharacter(source.charCodeAt(index)))
+            index += 1;
+        if (index === start)
             throw new SyntaxError('Expected JSON value');
-        return { start, end: this.index, kind: 'atomic' };
+        this.index = index;
+        return { start, end: index, kind: 'atomic' };
     }
 }
 function sourceNodeAtPath(root, path) {
@@ -229,9 +265,26 @@ function serializeReplacement(next, path, space = 0) {
         throw new TypeError(`Replacement at ${describeValuePath(path)} must be valid JSON data`, { cause: error });
     }
 }
-/** Reads a source-preserving inspection value and identifies information JSON.parse cannot retain. */
-export function inspectJsonSource(source) {
-    const value = JSON.parse(source);
+/** Paths are rebuilt from parent links only for the few nodes that report something. */
+function inspectionPath(frame) {
+    const path = [];
+    for (let current = frame; current.parent; current = current.parent)
+        path.push(current.segment);
+    return path.reverse();
+}
+/** Integers of at most 15 digits round-trip exactly; -0 is the one exception. */
+function isPlainSafeInteger(token) {
+    let index = token.charCodeAt(0) === MINUS ? 1 : 0;
+    if (token.length - index < 1 || token.length - index > 15)
+        return false;
+    if (index === 1 && token.length === 2 && token.charCodeAt(1) === 0x30)
+        return false;
+    for (; index < token.length; index += 1)
+        if (!isDigit(token.charCodeAt(index)))
+            return false;
+    return true;
+}
+function inspectSourceDiagnostics(source) {
     const tree = new JsonSourceScanner(source).parse();
     const diagnostics = [];
     const decimalKey = (token) => {
@@ -245,38 +298,42 @@ export function inspectJsonSource(source) {
         const significant = digits.replace(/0+$/, '');
         return `${negative ? '-' : ''}${significant}e${Number(exponent) - fraction.length + digits.length - significant.length}`;
     };
-    const pending = [{ node: tree, path: [], shadowed: false }];
+    const pending = [{ node: tree, parent: undefined, segment: '', shadowed: false }];
     while (pending.length) {
-        const { node, path, shadowed } = pending.pop();
+        const frame = pending.pop();
+        const { node, shadowed } = frame;
         if (node.kind === 'object') {
             const seen = new Set();
-            for (const property of node.properties ?? []) {
-                const childPath = [...path, property.key];
-                const childShadowed = shadowed || node.propertyIndex?.get(property.key) !== property.value;
+            for (const property of node.properties) {
+                const childShadowed = shadowed || node.propertyIndex.get(property.key) !== property.value;
+                const child = { node: property.value, parent: frame, segment: property.key, shadowed: childShadowed };
                 if (seen.has(property.key))
                     diagnostics.push({
-                        code: 'duplicate-key', sourcePath: childPath, token: JSON.stringify(property.key),
+                        code: 'duplicate-key', sourcePath: inspectionPath(child), token: JSON.stringify(property.key),
                         ...(childShadowed ? { shadowed: true } : {}),
                         start: property.start, end: property.end,
                         message: 'Duplicate object key; structured inspection shows the last occurrence. Source retains every occurrence.',
                     });
                 seen.add(property.key);
-                pending.push({ node: property.value, path: childPath, shadowed: childShadowed });
+                pending.push(child);
             }
         }
         else if (node.kind === 'array') {
-            node.items?.forEach((child, index) => pending.push({ node: child, path: [...path, index], shadowed }));
+            node.items.forEach((item, index) => pending.push({ node: item, parent: frame, segment: index, shadowed }));
         }
         else {
+            const first = source.charCodeAt(node.start);
+            if (first !== MINUS && !isDigit(first))
+                continue;
             const token = source.slice(node.start, node.end);
-            if (!/^-?[0-9]/.test(token))
+            if (isPlainSafeInteger(token))
                 continue;
             const number = Number(token);
             if (!Number.isFinite(number) || Object.is(number, -0)
                 || (Number.isInteger(number) && !Number.isSafeInteger(number))
                 || decimalKey(token) !== decimalKey(String(number))) {
                 diagnostics.push({
-                    code: 'unsafe-number', sourcePath: path, token, start: node.start, end: node.end,
+                    code: 'unsafe-number', sourcePath: inspectionPath(frame), token, start: node.start, end: node.end,
                     ...(shadowed ? { shadowed: true } : {}),
                     message: 'This numeric token cannot be safely edited through JavaScript numbers. Edit its exact value in Source.',
                 });
@@ -284,7 +341,20 @@ export function inspectJsonSource(source) {
         }
     }
     diagnostics.sort((a, b) => a.start - b.start);
-    return { value, diagnostics: diagnostics.map((item) => ({ ...item, help: sourceDiagnosticHelp(item.code) })) };
+    return diagnostics;
+}
+let lastInspection;
+/** Reads a source-preserving inspection value and identifies information JSON.parse cannot retain. */
+export function inspectJsonSource(source) {
+    const value = JSON.parse(source);
+    // Hosts inspect one text several times per change. The scan is the expensive
+    // part, so its result is kept for the most recent source; callers still get
+    // their own value, diagnostic objects, and paths.
+    const cached = lastInspection !== undefined && lastInspection.source === source ? lastInspection.diagnostics : undefined;
+    const diagnostics = cached ?? inspectSourceDiagnostics(source);
+    if (!cached)
+        lastInspection = { source, diagnostics };
+    return { value, diagnostics: diagnostics.map((item) => ({ ...item, sourcePath: [...item.sourcePath], help: sourceDiagnosticHelp(item.code) })) };
 }
 /** Replaces one existing JSON value while preserving every unrelated source byte. */
 export function replaceJsonValueInSource(source, path, next) {

package/dist/metadata.d.ts

@@ -133,5 +133,9 @@ export interface CompileJsonViewMetadataOptions {
     metadata?: unknown;
     /** Temporarily hides required-value diagnostics below paths for unfinished record drafts. */
     suppressRequiredPaths?: readonly ValuePath[];
+    /** `false` skips checking every document value against the schema, which is
+     * most of the compile time on large documents. The compiled schema, views, and
+     * all other diagnostics are unchanged; value diagnostics are omitted. */
+    validateValues?: boolean;
 }
 export declare function compileJsonViewMetadata(root: unknown, typeRegistry?: JsonViewTypeRegistry, options?: CompileJsonViewMetadataOptions): CompiledJsonViewMetadata;

package/dist/metadata.js

@@ -1,6 +1,6 @@
 import { MAX_HTML_VIEW_BYTES } from './html-view-limits.js';
 import { assertJsonDepth } from './json-limits.js';
-import { getValueAtPath, VALUE_PATH_MISSING } from './json-path.js';
+import { getValueAtPath, VALUE_PATH_MISSING, valuePathKey } from './json-path.js';
 import { compileSafePattern } from './safe-pattern.js';
 import { defaultTypeRegistry, JSON_VIEW_OPTION_COLORS } from './type-registry.js';
 import { compareDateValues, parseDateValue } from './date-type.js';
@@ -369,23 +369,34 @@ function canonicalValue(value) {
     return JSON.stringify(value);
 }
 export function matchesJsonViewPath(path, sourcePath) {
-    if (path.root !== '$' || path.segments.length !== sourcePath.length)
+    const segments = path.segments;
+    if (path.root !== '$' || segments.length !== sourcePath.length)
         return false;
-    return path.segments.every((segment, index) => {
-        const sourceSegment = sourcePath[index];
+    for (let index = 0; index < segments.length; index += 1) {
+        const segment = segments[index];
         if (segment.kind === 'wildcard')
-            return true;
-        if (segment.kind === 'property')
-            return segment.key === sourceSegment;
-        return segment.index === sourceSegment;
-    });
+            continue;
+        if ((segment.kind === 'property' ? segment.key : segment.index) !== sourcePath[index])
+            return false;
+    }
+    return true;
+}
+/** More concrete segments win, then longer paths, then the earlier declaration. */
+function outranks(candidate, current) {
+    if (candidate.specificity[0] !== current.specificity[0])
+        return candidate.specificity[0] > current.specificity[0];
+    if (candidate.specificity[1] !== current.specificity[1])
+        return candidate.specificity[1] > current.specificity[1];
+    return candidate.declarationIndex < current.declarationIndex;
 }
 export function schemaForJsonViewPath(schema, sourcePath) {
-    return schema
-        .filter((entry) => matchesJsonViewPath(entry.path, sourcePath))
-        .sort((left, right) => (right.specificity[0] - left.specificity[0]
-        || right.specificity[1] - left.specificity[1]
-        || left.declarationIndex - right.declarationIndex))[0];
+    // Keeps the earliest of the best-ranked matches, exactly as a stable sort would.
+    let winner;
+    for (const entry of schema) {
+        if (matchesJsonViewPath(entry.path, sourcePath) && (!winner || outranks(entry, winner)))
+            winner = entry;
+    }
+    return winner;
 }
 function parseDeclaredPath(value, expectedRoot, allowWildcard, metadataPath, diagnostics, scope, code, details = {}) {
     if (typeof value !== 'string') {
@@ -445,20 +456,20 @@ function compileSchema(value, diagnostics, typeRegistry) {
 }
 function inferSchemaOptions(root, schema) {
     for (const entry of schema) {
-        if (entry.descriptor.type !== 'select' && entry.descriptor.type !== 'multi-select')
+        const type = entry.descriptor.type;
+        if (type !== 'select' && type !== 'multi-select')
             continue;
         const options = new Set(entry.descriptor.options ?? []);
-        for (const location of expandSchemaLocations(root, entry)) {
-            if (entry.descriptor.type === 'select' && typeof location.value === 'string' && location.value !== '') {
-                options.add(location.value);
-            }
-            if (entry.descriptor.type === 'multi-select' && Array.isArray(location.value)) {
-                location.value.forEach((value) => {
-                    if (typeof value === 'string' && value !== '')
-                        options.add(value);
+        visitSchemaLocations(root, entry, (value) => {
+            if (type === 'select' && typeof value === 'string' && value !== '')
+                options.add(value);
+            if (type === 'multi-select' && Array.isArray(value)) {
+                value.forEach((item) => {
+                    if (typeof item === 'string' && item !== '')
+                        options.add(item);
                 });
             }
-        }
+        });
         entry.descriptor = { ...entry.descriptor, options: Array.from(options) };
     }
 }
@@ -622,10 +633,15 @@ function validateViewField(root, rows, viewPath, fieldPath, metadataPath, diagno
     }
     if (rows.length === 0)
         return;
-    const resolved = rows.map((row) => resolveJsonViewRowPath(root, row, fieldPath));
-    if (resolved.every((item) => item.value === JSON_VIEW_PATH_MISSING)) {
-        diagnostic(diagnostics, 'view', code, `Path ${JSON.stringify(fieldPath.source)} does not resolve on any record selected by ${JSON.stringify(viewPath.source)}`, metadataPath, { viewId, sourcePath: resolved[0]?.sourcePath, help: fieldHelp() });
+    // Only a field missing from every record is reported, so stop at the first record that has it.
+    let first;
+    for (const row of rows) {
+        const resolved = resolveJsonViewRowPath(root, row, fieldPath);
+        if (resolved.value !== JSON_VIEW_PATH_MISSING)
+            return;
+        first ??= resolved;
     }
+    diagnostic(diagnostics, 'view', code, `Path ${JSON.stringify(fieldPath.source)} does not resolve on any record selected by ${JSON.stringify(viewPath.source)}`, metadataPath, { viewId, sourcePath: first?.sourcePath, help: fieldHelp() });
 }
 function reserveViewId(raw, declarationIndex, usedIds) {
     const requested = typeof raw.id === 'string' && raw.id.trim() ? raw.id.trim() : `view-${declarationIndex + 1}`;
@@ -798,93 +814,140 @@ function compileViews(root, value, diagnostics, schema, typeRegistry) {
             }];
     });
 }
-function expandSchemaLocations(root, entry) {
-    const results = [];
-    const visit = (value, segmentIndex, sourcePath) => {
-        if (segmentIndex === entry.path.segments.length) {
-            results.push({ value, sourcePath });
+/** Visits every location a schema path selects, in document order, without
+ * allocating a path per location. Missing data is visited once at its deepest
+ * concrete prefix.
+ */
+function visitSchemaLocations(root, entry, visit) {
+    const segments = entry.path.segments;
+    const stack = [];
+    let snapshot;
+    const path = () => snapshot ??= stack.slice();
+    const report = (value, complete) => {
+        snapshot = undefined;
+        visit(value, path, complete);
+    };
+    const missing = (segmentIndex) => {
+        let pushed = 0;
+        for (let index = segmentIndex; index < segments.length; index += 1) {
+            const part = segments[index];
+            if (part.kind === 'wildcard')
+                break;
+            stack.push(part.kind === 'property' ? part.key : part.index);
+            pushed += 1;
+        }
+        report(JSON_VIEW_PATH_MISSING, stack.length === segments.length);
+        stack.length -= pushed;
+    };
+    const descend = (value, segmentIndex) => {
+        if (segmentIndex === segments.length) {
+            report(value, true);
             return;
         }
-        const segment = entry.path.segments[segmentIndex];
-        const missing = () => {
-            const remainder = entry.path.segments.slice(segmentIndex);
-            const concrete = [...sourcePath];
-            for (const part of remainder) {
-                if (part.kind === 'wildcard')
-                    break;
-                concrete.push(part.kind === 'property' ? part.key : part.index);
-            }
-            results.push({ value: JSON_VIEW_PATH_MISSING, sourcePath: concrete });
-        };
+        const segment = segments[segmentIndex];
         if (segment.kind === 'property') {
-            if (!isRecord(value)) {
-                missing();
+            if (!isRecord(value) || !own(value, segment.key)) {
+                missing(segmentIndex);
                 return;
             }
-            if (own(value, segment.key))
-                visit(value[segment.key], segmentIndex + 1, [...sourcePath, segment.key]);
-            else
-                missing();
+            stack.push(segment.key);
+            descend(value[segment.key], segmentIndex + 1);
+            stack.pop();
             return;
         }
         if (segment.kind === 'index') {
-            if (!Array.isArray(value)) {
-                missing();
+            if (!Array.isArray(value) || !own(value, String(segment.index))) {
+                missing(segmentIndex);
                 return;
             }
-            if (own(value, String(segment.index)))
-                visit(value[segment.index], segmentIndex + 1, [...sourcePath, segment.index]);
-            else
-                missing();
+            stack.push(segment.index);
+            descend(value[segment.index], segmentIndex + 1);
+            stack.pop();
             return;
         }
         if (Array.isArray(value)) {
-            value.forEach((child, index) => visit(child, segmentIndex + 1, [...sourcePath, index]));
+            value.forEach((child, index) => {
+                stack.push(index);
+                descend(child, segmentIndex + 1);
+                stack.pop();
+            });
             return;
         }
-        if (isRecord(value)) {
-            Object.entries(value).forEach(([key, child]) => visit(child, segmentIndex + 1, [...sourcePath, key]));
+        if (!isRecord(value)) {
+            missing(segmentIndex);
+            return;
+        }
+        for (const key of Object.keys(value)) {
+            stack.push(key);
+            descend(value[key], segmentIndex + 1);
+            stack.pop();
         }
-        else
-            missing();
     };
-    visit(root, 0, []);
-    return results;
+    descend(root, 0);
+}
+function underAnyPath(paths, sourcePath) {
+    return paths.some((path) => path.length <= sourcePath.length && path.every((part, index) => part === sourcePath[index]));
 }
-function validateResolvedSchemaValue(value, descriptor, entry, sourcePath, diagnostics, typeRegistry, suppressRequiredPaths) {
-    const details = { declaration: entry.declaration, sourcePath };
+function validateResolvedSchemaValue(value, descriptor, entry, path, diagnostics, typeRegistry, suppressRequiredPaths) {
+    // Most values are valid, so the path is only materialized for the ones that report.
+    const suppressed = (sourcePath) => suppressRequiredPaths.length > 0 && underAnyPath(suppressRequiredPaths, sourcePath);
     if (value === JSON_VIEW_PATH_MISSING) {
-        if (descriptor.required && !suppressRequiredPaths.some((path) => path.length <= sourcePath.length && path.every((part, index) => part === sourcePath[index]))) {
-            diagnostic(diagnostics, 'value', 'required-value-missing', 'Required value is missing', entry.metadataPath, details);
+        if (!descriptor.required)
+            return;
+        const sourcePath = path();
+        if (!suppressed(sourcePath)) {
+            diagnostic(diagnostics, 'value', 'required-value-missing', 'Required value is missing', entry.metadataPath, { declaration: entry.declaration, sourcePath });
         }
         return;
     }
     const issue = typeRegistry.validate(value, descriptor);
-    const suppressRequired = suppressRequiredPaths.some((path) => path.length <= sourcePath.length && path.every((part, index) => part === sourcePath[index]));
-    if (issue && !(suppressRequired && issue === 'A value is required')) {
-        diagnostic(diagnostics, 'value', 'invalid-typed-value', issue, entry.metadataPath, details);
-        return;
+    if (issue) {
+        const sourcePath = path();
+        if (!(issue === 'A value is required' && suppressed(sourcePath))) {
+            diagnostic(diagnostics, 'value', 'invalid-typed-value', issue, entry.metadataPath, { declaration: entry.declaration, sourcePath });
+            return;
+        }
     }
-    for (const warning of typeRegistry.warnings(value, descriptor)) {
-        diagnostic(diagnostics, 'value', 'typed-value-warning', warning, entry.metadataPath, { ...details, severity: 'warning' });
+    const warnings = typeRegistry.warnings(value, descriptor);
+    if (warnings.length === 0)
+        return;
+    const sourcePath = path();
+    for (const warning of warnings) {
+        diagnostic(diagnostics, 'value', 'typed-value-warning', warning, entry.metadataPath, { declaration: entry.declaration, sourcePath, severity: 'warning' });
     }
 }
 function validateSchemaValues(root, schema, diagnostics, typeRegistry, suppressRequiredPaths) {
+    // A complete location has one winner among the entries of its length, so it
+    // can only be claimed away from this entry by an overlapping higher-ranked
+    // entry. Cut-off locations are the only ones several entries can share.
     const visited = new Set();
     for (const entry of schema) {
-        for (const location of expandSchemaLocations(root, entry)) {
-            const winner = schemaForJsonViewPath(schema, location.sourcePath);
-            if (winner && winner !== entry)
-                continue;
-            const visitKey = JSON.stringify(location.sourcePath);
-            if (visited.has(visitKey))
-                continue;
-            visited.add(visitKey);
-            validateResolvedSchemaValue(location.value, entry.descriptor, entry, location.sourcePath, diagnostics, typeRegistry, suppressRequiredPaths);
-        }
+        const rivals = schema.filter((other) => other !== entry
+            && other.path.segments.length === entry.path.segments.length
+            && outranks(other, entry) && pathsOverlap(other.path, entry.path));
+        visitSchemaLocations(root, entry, (value, path, complete) => {
+            if (complete) {
+                if (rivals.length > 0) {
+                    const sourcePath = path();
+                    if (rivals.some((rival) => matchesJsonViewPath(rival.path, sourcePath)))
+                        return;
+                }
+            }
+            else {
+                const sourcePath = path();
+                const winner = schemaForJsonViewPath(schema, sourcePath);
+                if (winner && winner !== entry)
+                    return;
+                const visitKey = valuePathKey(sourcePath);
+                if (visited.has(visitKey))
+                    return;
+                visited.add(visitKey);
+            }
+            validateResolvedSchemaValue(value, entry.descriptor, entry, path, diagnostics, typeRegistry, suppressRequiredPaths);
+        });
     }
 }
-function compileMetadataValue(root, metadata, typeRegistry, recognized, inference, metadataSource = 'embedded', suppressRequiredPaths = []) {
+function compileMetadataValue(root, metadata, typeRegistry, recognized, inference, metadataSource = 'embedded', suppressRequiredPaths = [], validateValues = true) {
     const diagnostics = [];
     diagnoseUnknownProperties(metadata, ANNOTATION_PROPERTIES, ['$jsonviews'], diagnostics, 'metadata', 'unknown-annotation-property');
     const schema = compileSchema(metadata.schema, diagnostics, typeRegistry);
@@ -899,7 +962,7 @@ function compileMetadataValue(root, metadata, typeRegistry, recognized, inferenc
     // Inference is a presentation hint, not a user-authored validation contract.
     // A sampled collection can contain later values that do not match the guessed
     // type, and those values must not become upload-time errors.
-    if (metadataSource !== 'inferred') {
+    if (metadataSource !== 'inferred' && validateValues) {
         validateSchemaValues(root, schema, diagnostics, typeRegistry, suppressRequiredPaths);
     }
     return {
@@ -918,12 +981,13 @@ function compileMetadataValue(root, metadata, typeRegistry, recognized, inferenc
 export function compileJsonViewMetadata(root, typeRegistry = defaultTypeRegistry, options = {}) {
     assertJsonDepth(root);
     assertJsonDepth(options.metadata);
+    const validateValues = options.validateValues !== false;
     const inactive = () => ({
         root, status: 'none', recognized: false, active: false, schema: [], views: [], diagnostics: [],
     });
     const supplied = (metadata, metadataSource) => {
         if (isRecord(metadata) && metadata.version === 1) {
-            return compileMetadataValue(root, metadata, typeRegistry, true, undefined, metadataSource, options.suppressRequiredPaths);
+            return compileMetadataValue(root, metadata, typeRegistry, true, undefined, metadataSource, options.suppressRequiredPaths, validateValues);
         }
         const unsupported = isRecord(metadata) && Number.isInteger(metadata.version) && Number(metadata.version) > 0;
         return {
@@ -948,5 +1012,5 @@ export function compileJsonViewMetadata(root, typeRegistry = defaultTypeRegistry
     const inference = inferJsonViewMetadata(root);
     if (Object.keys(inference.schema).length === 0 && inference.views.length === 0)
         return inactive();
-    return compileMetadataValue(root, inference, typeRegistry, false, inference, 'inferred', options.suppressRequiredPaths);
+    return compileMetadataValue(root, inference, typeRegistry, false, inference, 'inferred', options.suppressRequiredPaths, validateValues);
 }

package/dist/source-default.js

@@ -1,17 +1,39 @@
 import { compileJsonViewMetadata } from './metadata.js';
 import { isJsonViewTableCandidate } from './table-suitability.js';
+/** Counts scalar values, stopping once the count passes the limit. */
+function countLeaves(root, limit) {
+    let leaves = 0;
+    const pending = [root];
+    while (pending.length) {
+        const value = pending.pop();
+        if (value !== null && typeof value === 'object')
+            pending.push(...Object.values(value));
+        else if ((leaves += 1) > limit)
+            break;
+    }
+    return leaves;
+}
 /** Initial presentation only. Never changes a user's selection during edits. */
 export function prefersSource(content, metadata) {
     try {
         const root = JSON.parse(content);
-        const compiled = compileJsonViewMetadata(root, undefined, metadata === undefined ? {} : { metadata });
-        if (compiled.metadataSource !== 'inferred' || compiled.views.length || isJsonViewTableCandidate(root))
+        // Every scalar takes a pretty-printed line of its own, so a document with
+        // more than 100 of them fails the size check below without a compile.
+        if (countLeaves(root, 100) > 100)
             return false;
         const formatted = JSON.stringify(root, null, 2);
         const lines = formatted.split('\n').length;
         if (formatted.length > 8000 || lines > 100)
             return false;
+        const compiled = compileJsonViewMetadata(root, undefined, metadata === undefined ? {} : { metadata });
+        if (compiled.metadataSource !== 'inferred' || compiled.views.length || isJsonViewTableCandidate(root))
+            return false;
         const entries = root !== null && typeof root === 'object' ? Object.values(root) : [];
+        // Dictionaries now fall back to properties when their fields differ. Keep
+        // that structured presentation instead of switching them to source.
+        if (!Array.isArray(root) && entries.length >= 2
+            && entries.every((value) => value !== null && typeof value === 'object' && !Array.isArray(value)))
+            return false;
         // A compact root with little visible information is easier to read whole
         // than by opening each nested value, even when nesting is only one level.
         if (entries.length <= 5 && formatted.length <= 3000 && lines <= 40

package/dist/table-suitability.d.ts

@@ -1,5 +1,5 @@
 /** Conservative eligibility shared by predicted views and automatic JSON tables. */
-/** Two or more records with fields can render as rows and columns. */
+/** Arrays imply rows; dictionaries need a substantial shared field structure. */
 export declare function isJsonViewTableCandidate(value: unknown): boolean;
 /** Shared scalar paths only; never explodes arrays or rewrites source records. */
 export declare function inferFlatColumnPaths(value: unknown): string[][] | undefined;

package/dist/table-suitability.js

@@ -9,11 +9,24 @@ function isReadable(value) {
         || (typeof value === 'number' && Number.isFinite(value))
         || (typeof value === 'string' && value.trim().length > 0);
 }
-/** Two or more records with fields can render as rows and columns. */
+/** Arrays imply rows; dictionaries need a substantial shared field structure. */
 export function isJsonViewTableCandidate(value) {
     const rows = Array.isArray(value) ? value : isRecord(value) ? Object.values(value) : [];
-    return rows.length >= MIN_RECORDS && rows.every(isRecord)
-        && rows.some((row) => Object.keys(row).some((key) => key !== '$jsonviews'));
+    if (rows.length < MIN_RECORDS || !rows.every(isRecord))
+        return false;
+    const fields = rows.map((row) => Object.keys(row).filter((key) => key !== '$jsonviews'));
+    if (Array.isArray(value))
+        return fields.some((keys) => keys.length > 0);
+    // Inspect the whole dictionary so late, unrelated sections cannot be missed.
+    // Nested values remain intact: only the fields used as columns matter here.
+    const counts = new Map();
+    for (const keys of fields) {
+        for (const key of keys)
+            counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    const shared = new Set([...counts].filter(([, count]) => count / rows.length >= 0.8).map(([key]) => key));
+    return shared.size > 0 && shared.size / counts.size >= 0.5
+        && fields.every((keys) => keys.some((key) => shared.has(key)));
 }
 /** Shared scalar paths only; never explodes arrays or rewrites source records. */
 export function inferFlatColumnPaths(value) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@script-it/json-views-core",
-  "version": "0.1.0-beta.1",
+  "version": "2026.10.25",
   "description": "JSON Views metadata, path, validation, and source-preserving editing core",
   "license": "MIT",
   "type": "module",
@@ -29,7 +29,7 @@
   "devDependencies": {
     "ajv": "^8.20.0",
     "typescript": "^5.9.3",
-    "vitest": "3.2.7"
+    "vitest": "4.1.11"
   },
   "dependencies": {
     "re2js": "^2.8.6"