@limaformat/lima 0.7.0 → 0.7.1

package/CHANGELOG.md

@@ -12,6 +12,27 @@ carry their own.
 
 ## [Unreleased]
 
+## [0.7.1] — 2026-10-31
+
+### Security
+
+- A few KB of references could copy millions of nodes before the limit on the result stopped them, and interpolation
+  kept growing a value past its limit. Resolution now counts what it copies and stops (References §4.1), with the
+  error of an oversized result.
+
+### Fixed
+
+- A value or sequence item followed by whitespace other than spaces kept it at the top level: `draft: false` with a no-break space
+  after it is now the boolean, as in a block (Core §4).
+- `.0` and `-.0` are zero, not an underflow.
+- A line with an empty key in a block is an unrecognised line.
+- Spaces before a flow value in a sequence item threw an error without a Lima code.
+- Messages no longer quote control or direction characters of the source, and shorten a long line.
+
+### Added
+
+- `LimaError` is exported.
+
 ## [0.7.0] — 2026-10-30
 
 Lima Core 1.2 and References 2.1: an unquoted key may be written in any

package/dist/block.js

@@ -13,7 +13,7 @@ import { stripKeyQuotes, stripComment, stripCommentKeepEscapes, parseQuotedOrTyp
 import { KEY_GRAMMAR_HINT, specificKeyHint } from './key-hints.js';
 import { parseFlowOrScalarValue, parseFlowSequence } from './flow.js';
 import { buildBlockScalar } from './block-scalar.js';
-import { LimaError } from './errors.js';
+import { LimaError, printableLine } from './errors.js';
 import { isTrimWhitespace } from './chars.js';
 import { BlockCursor } from './block-cursor.js';
 const DASH_PREFIX_RE = /^-\s+/;
@@ -167,7 +167,7 @@ const cursorAfterDash = (cursor) => {
 /** Core 1.1 §10.1: a line in a block whose key the key grammar (§5.1) rejects, in strict mode. */
 const unrecognizedKeyLine = (line, trimmed) => new LimaError({
     code: 'UNRECOGNIZED_LINE', line,
-    message: `Lima: unrecognised line at line ${line}: "${trimmed}"${specificKeyHint(trimmed) ?? KEY_GRAMMAR_HINT}`,
+    message: `Lima: unrecognised line at line ${line}: "${printableLine(trimmed)}"${specificKeyHint(trimmed) ?? KEY_GRAMMAR_HINT}`,
 });
 /** Shared block grammar consuming one mutable physical-line cursor. */
 const parseCursorBlock = (cursor, baseIndent, ctx, baseLine, builder, compact = false) => {
@@ -208,7 +208,7 @@ const parseCursorBlock = (cursor, baseIndent, ctx, baseLine, builder, compact =
                 const keyRaw = colonPos !== -1
                     ? trimEndSlice(trimmed, 0, colonPos)
                     : bareKey ? trimEndSlice(trimmed, 0, trimmed.length - 1) : '';
-                if (keyRaw !== '' && !isValidKey(keyRaw)) {
+                if ((keyRaw !== '' || colonPos !== -1) && !isValidKey(keyRaw)) {
                     // §5.1: not a usable key — an unrecognised line, skipped in non-strict mode and an error in strict
                     // mode, as at the top level (Core 1.1 §10.1)
                     if (ctx.strict)
@@ -268,9 +268,7 @@ const parseCursorBlock = (cursor, baseIndent, ctx, baseLine, builder, compact =
             if (items === null)
                 items = [];
             const afterDashRaw = cursorAfterDash(cursor);
-            let afterDash = afterDashRaw;
-            if (afterDash.includes('#'))
-                afterDash = stripComment(afterDash);
+            const afterDash = afterDashRaw.includes('#') ? stripComment(afterDashRaw) : afterDashRaw.trimEnd();
             const afterDashCol = wantSource ? cursor.indent + dashPrefixLen(cursor) : 0;
             const afterDashTab = wantSource && ctx.tabAdjust ? [ctx.tabAdjust[line - 1] ?? 0] : undefined;
             const dashSource = wantSource ? ({
@@ -331,7 +329,7 @@ const parseCursorBlock = (cursor, baseIndent, ctx, baseLine, builder, compact =
                 // The key sits after `- `, two columns past the dash.
                 const valueCol = wantSource ? afterDashCol + valueStart + leadingWsLen(afterDash.slice(valueStart)) : 0;
                 pendingColumn = cursor.indent + dashPrefixLen(cursor);
-                pendingItem = builder.createMappingWith(key, inlineOrBlockScalar(raw, trimSlice(afterDashRaw, valueStart, afterDashRaw.length) === '|', pendingColumn, line, valueCol, wantSource ? afterDashRaw.slice(valueStart) : raw, cursor, ctx, builder));
+                pendingItem = builder.createMappingWith(key, inlineOrBlockScalar(raw, trimSlice(afterDashRaw, valueStart, afterDashRaw.length) === '|', pendingColumn, line, valueCol, wantSource ? trimSlice(afterDashRaw, valueStart, afterDashRaw.length) : raw, cursor, ctx, builder));
                 // the item's later keys at its key column; any other line is the block loop's (§7.2)
                 while (cursor.valid && cursor.indent === pendingColumn) {
                     const continuationLine = baseLine + cursor.lineIndex;
@@ -399,7 +397,7 @@ const parseCursorBlock = (cursor, baseIndent, ctx, baseLine, builder, compact =
             const keyRaw = colonPos !== -1
                 ? trimEndSlice(trimmed, 0, colonPos)
                 : bareKey ? trimEndSlice(trimmed, 0, trimmed.length - 1) : '';
-            if (keyRaw !== '' && !isValidKey(keyRaw)) {
+            if ((keyRaw !== '' || colonPos !== -1) && !isValidKey(keyRaw)) {
                 // §5.1: not a usable key — an unrecognised line, skipped in non-strict mode and an error in strict
                 // mode, as at the top level (Core 1.1 §10.1)
                 if (ctx.strict)

package/dist/core.js

@@ -221,7 +221,7 @@ const parseCoreGeneric = (frontMatter, ctx, builder, computeDepth) => {
             }
             const val = frontMatter.slice(rawStart, valueEnd);
             const hasHash = val.includes('#');
-            const uncommented = hasHash ? stripComment(val) : val;
+            const uncommented = hasHash ? stripComment(val) : val.trimEnd();
             // The physical anchor keeps `\#` but drops a real comment, so a
             // `${…}`-shaped token inside a trailing comment is not scanned (§2.4).
             const source = wantSource ? {

package/dist/errors.d.ts

@@ -19,6 +19,8 @@ export interface LimaDiagnostic {
     partial?: string;
     path?: string;
 }
+/** A line of the source for a message: shortened, and no control or direction character reaches a terminal. */
+export declare const printableLine: (text: string) => string;
 export declare class LimaError extends Error {
     readonly code: LimaDiagnosticCode;
     readonly line?: number;

package/dist/errors.js

@@ -8,6 +8,8 @@
  * module directly rather than duplicating it) inspect *why* a parse failed
  * without re-parsing the message string.
  */
+/** A line of the source for a message: shortened, and no control or direction character reaches a terminal. */
+export const printableLine = (text) => (text.length > 120 ? `${text.slice(0, 120)}…` : text).replace(/[\u0000-\u001f\u007f-\u009f\u200e\u200f\u202a-\u202e\u2066-\u2069]/g, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, '0')}`);
 export class LimaError extends Error {
     code;
     line;

package/dist/index.d.ts

@@ -12,5 +12,6 @@
  * retained as its deprecated compatibility alias.
  */
 export { parseCore, type CoreOptions, type Diagnostic } from './core.js';
+export { LimaError, type LimaDiagnostic, type LimaDiagnosticCode } from './errors.js';
 export { parseReferences, parse, type ParseMode, type ParseOptions } from './references2.js';
 export type ReferencesOptions = import('./references2.js').ParseOptions;

package/dist/index.js

@@ -12,4 +12,5 @@
  * retained as its deprecated compatibility alias.
  */
 export { parseCore } from './core.js';
+export { LimaError } from './errors.js';
 export { parseReferences, parse } from './references2.js';

package/dist/references2.js

@@ -1,5 +1,5 @@
 /** Lima References 2.1 resolver. References 1.0 remains isolated in references.ts. */
-import { canonicalString, codepointLength, countNodes, ingestPartialValue, PARTIAL_COUNT_LIMIT, PARTIAL_NAME_LENGTH_LIMIT, PARTIAL_NODE_LIMIT, RESULT_NODE_LIMIT, SCALAR_LENGTH_LIMIT, } from './value.js';
+import { canonicalString, codepointLength, countNodes, ingestPartialValue, PARTIAL_COUNT_LIMIT, PARTIAL_NAME_LENGTH_LIMIT, PARTIAL_NODE_LIMIT, RESOLUTION_COPY_LIMIT, RESULT_NODE_LIMIT, SCALAR_LENGTH_LIMIT, } from './value.js';
 import { isValidUnquotedKey } from './key-grammar.js';
 import { validateDocument } from './document.js';
 import { NESTING_DEPTH_LIMIT, parseCoreValidated, parseCoreWithPositions, toPlainValue, } from './core.js';
@@ -13,13 +13,44 @@ const TARGET_EDGE_BUDGET = MAX_EDGES - 1;
 const referenceResourceStatuses = new WeakMap();
 /** Copies a pure-reference target and stamps the new insertion without
  * discarding provenance already attached to the copied root (R-112). */
-const copyWithInsertion = (target, insertedAt) => {
+const copyWithInsertion = (target, insertedAt, ctx) => {
+    const earliest = ctx.earliestInsertion;
+    ctx.earliestInsertion = earliest === null ? insertedAt : earliestParticipant([earliest, insertedAt]);
+    if (!ctx.overflowed) {
+        ctx.copied += countPositioned(target);
+        ctx.overflowed = ctx.copied > RESOLUTION_COPY_LIMIT;
+    }
+    // the result is lost by now: resolution only goes on to see the earliest insertion
+    if (ctx.overflowed)
+        return { kind: 'null', line: 0 };
     const copy = deepCopyPositioned(target);
     const priorInsertions = copy.insertedAt === undefined
         ? copy.priorInsertions
         : [...(copy.priorInsertions ?? []), copy.insertedAt];
     return { ...copy, insertedAt, priorInsertions };
 };
+const countPositioned = (v) => {
+    let count = 1;
+    if (v.kind === 'array')
+        for (const item of v.items)
+            count += countPositioned(item);
+    if (v.kind === 'mapping')
+        for (const child of v.entries.values())
+            count += countPositioned(child);
+    return count;
+};
+const newContext = (cache) => ({
+    diagnostics: [], copied: 0, overflowed: false, earliestInsertion: null, ...(cache ? { cache } : {}),
+});
+/** The error of a document whose references would copy past RESOLUTION_COPY_LIMIT: that of an oversized result. */
+const overflowError = (ctx) => {
+    const winner = ctx.earliestInsertion;
+    return new LimaError({
+        code: 'RESOURCE_LIMIT', line: winner?.line ?? 1, token: winner?.token,
+        ...(winner?.offset !== undefined ? { column: winner.offset + 1 } : {}),
+        message: `Lima: result exceeds maximum size of ${RESULT_NODE_LIMIT} total nodes at line ${winner?.line ?? 1}`,
+    });
+};
 const addDiagnostic = (ctx, diagnostic, offset = 0) => {
     ctx.diagnostics.push({ ...diagnostic, offset });
 };
@@ -58,10 +89,10 @@ export const resolveDocumentReferenceTarget = (parsed, path) => {
         return { status: resourceStatus };
     if (resourceStatus === 'invalid')
         return { status: 'unresolved' };
-    const ctx = { diagnostics: [], cache: new WeakMap() };
+    const ctx = newContext(new WeakMap());
     const stack = new Set([target.root]);
     const resolved = resolveNode(target.root, document, new Map(), ctx, TARGET_EDGE_BUDGET, stack);
-    if (!resolved.complete || ctx.diagnostics.length > 0)
+    if (!resolved.complete || ctx.overflowed || ctx.diagnostics.length > 0)
         return { status: 'unresolved' };
     const selected = lookupPath(resolved.value, target.tail);
     return selected === undefined
@@ -116,9 +147,9 @@ const documentReferenceResourceStatus = (parsed) => {
     const cached = referenceResourceStatuses.get(document);
     if (cached !== undefined)
         return cached;
-    const ctx = { diagnostics: [], cache: new WeakMap() };
+    const ctx = newContext(new WeakMap());
     const resolved = resolveDocument(document, new Map(), ctx);
-    let valid = !ctx.diagnostics.some((diagnostic) => diagnostic.code === 'RESOURCE_LIMIT');
+    let valid = !ctx.overflowed && !ctx.diagnostics.some((diagnostic) => diagnostic.code === 'RESOURCE_LIMIT');
     if (valid) {
         try {
             assertResolvedDocumentResourceLimits(resolved);
@@ -220,7 +251,7 @@ const resolveNodeUncached = (node, document, partials, ctx, remainingEdges, stac
             // `partialToPositioned` never annotates partial targets: partials are
             // inert and have no source token before this document insertion.
             return {
-                value: copyWithInsertion(target, { line: pure.line, offset: pure.offset, token: pure.token }),
+                value: copyWithInsertion(target, { line: pure.line, offset: pure.offset, token: pure.token }, ctx),
                 complete: true,
             };
         }
@@ -235,7 +266,7 @@ const resolveNodeUncached = (node, document, partials, ctx, remainingEdges, stac
         return {
             // `selected` may itself be the root inserted by an earlier reference;
             // both it and this outer copy participate in final-structure errors.
-            value: copyWithInsertion(selected, { line: pure.line, offset: pure.offset, token: pure.token }),
+            value: copyWithInsertion(selected, { line: pure.line, offset: pure.offset, token: pure.token }, ctx),
             complete: true,
         };
     }
@@ -280,6 +311,8 @@ const resolveNodeUncached = (node, document, partials, ctx, remainingEdges, stac
             code: 'RESOURCE_LIMIT', line: first.line, token: first.token,
             message: `Lima: scalar exceeds maximum length of ${SCALAR_LENGTH_LIMIT} code points at line ${first.line}`,
         }, first.offset);
+        // the document has failed; a value that holds this one still exceeds the limit, and none grows further
+        output = output.slice(0, 2 * (SCALAR_LENGTH_LIMIT + 1));
     }
     return { value: { ...node, value: output, references2: unresolvedTokens }, complete };
 };
@@ -373,8 +406,10 @@ const parseInternal = (frontMatter, options, useResolveCache) => {
         return parseCoreValidated(frontMatter, options);
     }
     const document = parseCoreWithPositions(frontMatter, { strict: options?.strict ?? false, onWarning: options?.onWarning });
-    const ctx = { diagnostics: [], ...(useResolveCache ? { cache: new WeakMap() } : {}) };
+    const ctx = newContext(useResolveCache ? new WeakMap() : undefined);
     const resolved = resolveDocument(document, partials, ctx);
+    if (ctx.overflowed)
+        throw overflowError(ctx);
     if (options?.strict)
         for (const value of resolved.values())
             scanUnresolved(value, ctx);

package/dist/scalars.js

@@ -187,7 +187,7 @@ const parseDateUTC = (str, strict = false, line = 0) => {
 const NUMBER_RE = /^-?(?:(?:0|[1-9][0-9]*)(?:\.[0-9]+)?|\.[0-9]+)(?:[eE][+-]?[0-9]+)?$/;
 const DATE_PRE_RE = /\d[\d\-:.\/a-zA-Z]{4,}/;
 const isFloatForm = (str) => str.includes('.') || str.includes('e') || str.includes('E');
-const isZeroLiteral = (str) => /^0+(\.0+)?$/.test(str.replace(/^-/, '').split(/[eE]/)[0]);
+const isZeroLiteral = (str) => /^(?:0+(?:\.0+)?|\.0+)$/.test(str.replace(/^-/, '').split(/[eE]/)[0]);
 export const NO_SPAN_VALUE = Symbol('NO_SPAN_VALUE');
 /**
  * Parses allocation-free scalar forms whose complete grammar can be proven

package/dist/structure.js

@@ -15,7 +15,7 @@
  * these lines, as Core 1.0 did in both modes.
  */
 import { isTrimWhitespace } from './chars.js';
-import { LimaError } from './errors.js';
+import { LimaError, printableLine } from './errors.js';
 import { isValidUnquotedKey } from './key-grammar.js';
 import { KEY_GRAMMAR_HINT, specificKeyHint } from './key-hints.js';
 /**
@@ -59,7 +59,7 @@ export function checkRangeLines(frontMatter, start, end, line, owner, valueStart
                 const text = frontMatter.slice(pos, stop);
                 throw new LimaError({
                     code: 'UNRECOGNIZED_LINE', line: current,
-                    message: `Lima: unrecognised line at line ${current}: "${text}"${hint(text)}`,
+                    message: `Lima: unrecognised line at line ${current}: "${printableLine(text)}"${hint(text)}`,
                 });
             }
             if (owner === 'mapping' && base === -1)

package/dist/value.d.ts

@@ -60,6 +60,12 @@ export declare const PARTIAL_COUNT_LIMIT = 128;
 export declare const PARTIAL_NAME_LENGTH_LIMIT = 128;
 export declare const PARTIAL_NODE_LIMIT = 4096;
 export declare const RESULT_NODE_LIMIT = 65536;
+/**
+ * Nodes a resolution may copy (References §4.1: limits are validated during expansion). Each value is resolved
+ * for at most four edge budgets, so a document within RESULT_NODE_LIMIT stays far below this. Past it the result
+ * cannot fit, and copying on would only fill the memory: a few KB of references can reach millions of nodes.
+ */
+export declare const RESOLUTION_COPY_LIMIT: number;
 export declare const SCALAR_LENGTH_LIMIT = 16384;
 /**
  * Counts Unicode code points (what every length-limit check in this

package/dist/value.js

@@ -63,6 +63,12 @@ export const PARTIAL_COUNT_LIMIT = 128;
 export const PARTIAL_NAME_LENGTH_LIMIT = 128;
 export const PARTIAL_NODE_LIMIT = 4096;
 export const RESULT_NODE_LIMIT = 65536;
+/**
+ * Nodes a resolution may copy (References §4.1: limits are validated during expansion). Each value is resolved
+ * for at most four edge budgets, so a document within RESULT_NODE_LIMIT stays far below this. Past it the result
+ * cannot fit, and copying on would only fill the memory: a few KB of references can reach millions of nodes.
+ */
+export const RESOLUTION_COPY_LIMIT = 16 * RESULT_NODE_LIMIT;
 export const SCALAR_LENGTH_LIMIT = 16384;
 /**
  * Counts Unicode code points (what every length-limit check in this

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@limaformat/lima",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "Lima frontmatter parser — LIMA Is Metadata Annotation",
   "keywords": ["frontmatter", "parser", "yaml", "markdown", "metadata"],
   "homepage": "https://limaformat.dev",