@limaformat/lima 0.5.0 → 0.6.0

package/CHANGELOG.md

@@ -4,13 +4,99 @@ All notable changes to `@limaformat/lima` are documented in this file.
 
 The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 This package's version number tracks its own release history and is
-independent of the Lima specification version — [Lima Core
-1.0](https://github.com/limaformat/lima/blob/main/docs/lima-core-1.0-spec.md)
+independent of the Lima specification versions — [Lima Core
+1.1](https://github.com/limaformat/lima/blob/main/docs/lima-core-1.0-spec.md)
 and [Lima References
-1.0](https://github.com/limaformat/lima/blob/main/docs/lima-references-1.0-spec.md)
-are both frozen regardless of what this file shows.
+2.0](https://github.com/limaformat/lima/blob/main/docs/lima-references-2.0-spec.md)
+carry their own.
 
-## [Unreleased]
+## [0.6.0] — 2026-10-28
+
+Lima Core 1.1: strict mode rejects a content line that belongs to no
+structure, which Core 1.0 skipped in both modes. Core 1.1 also settles
+cases Core 1.0 left open, where the three implementations differed; some
+non-strict results change with them (below).
+
+### Changed
+
+- Strict mode throws `INVALID_INDENTATION` for a line indented after a
+  top-level key with an inline value — the lines after a YAML `>`, `|-` or
+  `|+`, a key indented by a tab, freetext after a value — as it already did
+  one level down; the message names the YAML marker and what Lima writes
+  instead.
+- Strict mode throws the new `UNRECOGNIZED_LINE` for an unindented line that
+  matches no key pattern: a key without its `: `, a dotted or otherwise
+  invalid key, a YAML `---` / `...` marker, a quoted key broken by a newline.
+- A line of a block mapping whose key the key grammar rejects (`a.b: value`,
+  `bad key: value`), skipped in strict mode until now, throws `UNRECOGNIZED_LINE`
+  too; an indented line below a block mapping's base indentation, or after a
+  `|` scalar a column-0 comment ended, throws `INVALID_INDENTATION`.
+- `LimaDiagnosticCode` gains `'UNRECOGNIZED_LINE'`.
+- A bare key's sequence may start at the key's own column, as YAML writes
+  it (`tags:` / `- a` / `- b`), at any level (Core 1.1 §7.2). At the top
+  level this was read so by accident; one level down the sequence and the
+  keys after it were lost.
+- An item whose value is a flow sequence (`- [a, b]`, `- []`) is a nested
+  sequence (Core 1.1 §7.2): `null` in non-strict mode, `INVALID_FLOW_SYNTAX`
+  in strict mode.
+- Indentation is spaces only (Core 1.1 §7.1): a line whose spaces are followed
+  by other whitespace, such as U+00A0, before its content is unrecognised —
+  skipped in non-strict mode, an error in strict mode. Whitespace is defined
+  once (§1), as the set every check already used.
+  TypeScript counted such whitespace as indentation.
+- An object item's later keys stand at its first key's column (§7.2): a line
+  of the item deeper than that is skipped in non-strict mode, and one less
+  indented ends the item; strict mode throws `INVALID_INDENTATION` for
+  either. Any deeper line was taken as a key of the item.
+
+### Fixed
+
+- A `|` scalar as an object item's first key measured its body from the dash
+  plus two columns, so after wider whitespace (`-   a: |`) it took the item's
+  next key as text; it measures from the key's column (§6.1.5, §7.2).
+- In strict mode, a line deeper than a nested `|` scalar's key, after a line
+  of other whitespace that ended the scalar, was dropped without an error; it
+  throws `INVALID_INDENTATION`.
+- A top-level `key:` at the very end of the input, without a line
+  terminator, was no key at all and vanished; it is `null`, as at any nested
+  level and in the Rust and Go implementations, and as Core 1.1 §4 now says.
+  This changes a non-strict result too.
+- A `|` with no content lines (`a: |` at the end of a block, or of the
+  input) was the string `"|"`; it is `""` (Core 1.1 §6.1.5).
+- A block of mapping entries with a sequence item in it, or the reverse, was
+  an empty sequence in non-strict mode, all its entries lost; the first kind
+  wins and a line of the other kind is skipped (Core 1.1 §7.1).
+- An item value that begins with `[` but is no flow sequence (`- [x] done`),
+  or with `{` and does not close (`- {a: 1`), throws `INVALID_FLOW_SYNTAX`
+  in strict mode, as an inline value does.
+- `key: | # c` below the top level, in a block mapping or an object item,
+  was a block scalar; it is the string `"|"`, as at the top level — the
+  marker stands alone (§6.1.5).
+
+The shared conformance corpus is at 336 Core cases: the 218 Core 1.0 cases
+without the 8 that Core 1.1 supersedes, plus 126 Core 1.1 cases
+(`corpus/core-1.1/`).
+
+## [0.5.1] — 2026-10-28
+
+Core errata `1.0.10`: aligned top-level values are trimmed, as Core 1.0
+always required.
+
+### Fixed
+
+- A top-level inline value kept every space after `: ` but the first:
+  `title:   Hello` read `'  Hello'`, and `n:    42` the string `'   42'`
+  instead of the integer 42 — against §4 step 3 and the §4 and §5.1
+  examples. Nested keys were not affected. The top-level entry now skips the
+  whitespace after the separator before reading the value, as the block
+  mapping does; the References 2.0 columns it reports were already physical
+  and are unchanged.
+
+The shared conformance corpus grows to 218 Core cases (7 new, `since:
+"1.0.10"`); TypeScript, Rust, and Go pass all of them.
+
+A unit test in `src/block.test.ts` had asserted the defect (`key:  value`
+→ `' value'`); it now asserts the specified `'value'`.
 
 ## [0.5.0] — 2026-09-09
 

package/README.md

@@ -57,7 +57,7 @@ public API. The normative rules are defined in the
 Why Lima exists, the case against YAML, and security rationale:
 **[repository README](https://github.com/limaformat/lima#readme)**.
 
-The [Lima Core 1.0](https://github.com/limaformat/lima/blob/main/docs/lima-core-1.0-spec.md)
+The [Lima Core 1.1](https://github.com/limaformat/lima/blob/main/docs/lima-core-1.0-spec.md)
 and [Lima References 2.0](https://github.com/limaformat/lima/blob/main/docs/lima-references-2.0-spec.md)
 specifications are the source of truth for these public entry points. The
 frozen References 1.0 implementation remains available internally to run its

package/dist/block-cursor.d.ts

@@ -1,8 +1,9 @@
 /**
  * Allocation-free physical-line cursor over one top-level block extent.
- * Positions are UTF-16 code-unit offsets. Structural boundaries are ASCII;
- * indentation additionally follows the complete whitespace predicate used by
- * `trimStart()`, matching the existing block grammar.
+ * Positions are UTF-16 code-unit offsets. Indentation is the run of spaces
+ * (Core 1.1 §7.1); other whitespace after it, such as U+00A0, starts the
+ * content of a line that has any, and only a blank or comment line looks
+ * past it (the complete whitespace predicate used by `trimStart()`).
  */
 export declare class BlockCursor {
     readonly source: string;

package/dist/block-cursor.js

@@ -1,9 +1,10 @@
 import { isTrimWhitespace } from './chars.js';
 /**
  * Allocation-free physical-line cursor over one top-level block extent.
- * Positions are UTF-16 code-unit offsets. Structural boundaries are ASCII;
- * indentation additionally follows the complete whitespace predicate used by
- * `trimStart()`, matching the existing block grammar.
+ * Positions are UTF-16 code-unit offsets. Indentation is the run of spaces
+ * (Core 1.1 §7.1); other whitespace after it, such as U+00A0, starts the
+ * content of a line that has any, and only a blank or comment line looks
+ * past it (the complete whitespace predicate used by `trimStart()`).
  */
 export class BlockCursor {
     source;
@@ -50,6 +51,9 @@ export class BlockCursor {
                 } while (content < end);
             }
         }
+        // other whitespace before content is no indentation: the content starts at it (Core 1.1 §7.1)
+        if (content > asciiEnd && content < end && this.source.charCodeAt(content) !== 35)
+            content = asciiEnd;
         this.lineStart = start;
         this.lineEnd = end;
         this.contentStart = content;

package/dist/block.js

@@ -9,8 +9,8 @@
  * never resolves a reference in the first place).
  */
 import { checkKeyLength, checkDuplicateKey, NESTING_DEPTH_LIMIT } from './normalize.js';
-import { stripKeyQuotes, stripComment, stripCommentKeepEscapes, parseQuotedOrTyped, closingQuoteIndex, isValidKey, positionedBuilder, } from './scalars.js';
-import { parseFlowMapping, parseFlowOrScalarValue } from './flow.js';
+import { stripKeyQuotes, stripComment, stripCommentKeepEscapes, parseQuotedOrTyped, closingQuoteIndex, isValidKey, } from './scalars.js';
+import { parseFlowOrScalarValue, parseFlowSequence } from './flow.js';
 import { buildBlockScalar } from './block-scalar.js';
 import { LimaError } from './errors.js';
 import { isTrimWhitespace } from './chars.js';
@@ -48,9 +48,10 @@ const inlineSource = (wantSource, ctx, keyLine, valueCol, rawUndecoded) => wantS
     raw: physicalRaw(rawUndecoded), line: keyLine, col: valueCol,
     tabAdjust: ctx.tabAdjust ? [ctx.tabAdjust[keyLine - 1] ?? 0] : undefined,
 }) : undefined;
-const inlineOrBlockScalar = (raw, keyIndent, keyLine, valueCol, rawUndecoded, cursor, ctx, builder) => {
-    const wantSource = builder === positionedBuilder;
-    if (raw !== '|') {
+/** An inline value, or a `|` block scalar when `marker`: the value is `|` alone (§6.1.5; `| # c` is the string `|`). */
+const inlineOrBlockScalar = (raw, marker, keyIndent, keyLine, valueCol, rawUndecoded, cursor, ctx, builder) => {
+    const wantSource = builder.positions === true;
+    if (!marker) {
         const value = parseFlowOrScalarValue(raw, ctx, keyLine, builder, inlineSource(wantSource, ctx, keyLine, valueCol, rawUndecoded));
         cursor.next();
         return value;
@@ -58,7 +59,9 @@ const inlineOrBlockScalar = (raw, keyIndent, keyLine, valueCol, rawUndecoded, cu
     cursor.next(); // past the `key: |` line
     const bodyLines = [];
     while (cursor.valid) {
-        if (!cursor.empty && cursor.asciiIndent <= keyIndent)
+        // the scalar's own extent (§6.1.5, `buildBlockScalar`): a line of spaces only is empty, any other ends it at the
+        // key's column or less — a line of other whitespace too, which is content here
+        if (cursor.lineEnd - cursor.lineStart > cursor.asciiIndent && cursor.asciiIndent <= keyIndent)
             break;
         bodyLines.push(cursor.source.slice(cursor.lineStart, cursor.lineEnd));
         cursor.next();
@@ -83,6 +86,15 @@ export const findKeySep = (s) => {
  * the original source. Strings are materialized only when grammar or scalar
  * parsing needs their content.
  */
+/**
+ * `source.slice(start, end).trimEnd()`: a key, or a line's content, keeps the whitespace it starts with, which makes it
+ * no key (Core 1.1 §7.1: other whitespace before content is no indentation).
+ */
+const trimEndSlice = (source, start, end) => {
+    while (end > start && isTrimWhitespace(source.charCodeAt(end - 1)))
+        end--;
+    return source.slice(start, end);
+};
 /** `source.slice(start, end).trim()` with no temporary untrimmed substring. */
 const trimSlice = (source, start, end) => {
     if (start < end) {
@@ -115,6 +127,30 @@ const skipEmptyAndCommentLines = (cursor) => {
     while (cursor.valid && (cursor.empty || cursor.firstCode === 35))
         cursor.next();
 };
+/**
+ * §7.2: a sequence item is a line of `-` alone or `-` followed by whitespace; `---` or `-x` is none (Core 1.1). The
+ * cursor is on a line with content.
+ */
+const isSequenceItem = (cursor) => {
+    if (cursor.firstCode !== 45)
+        return false;
+    const next = cursor.contentStart + 1;
+    return next === cursor.lineEnd || isTrimWhitespace(cursor.source.charCodeAt(next));
+};
+/**
+ * Core 1.1 §7.2: the block of a bare key at `keyColumn` — deeper than the key (§7.1 rule 3), or a sequence that
+ * starts at the key's own column, which `compact` parsing ends at that column's first line that is no item. Null
+ * without either. The cursor is on the first content line after the key.
+ */
+const blockOfBareKey = (cursor, keyColumn, ctx, baseLine, builder) => {
+    if (!cursor.valid)
+        return null;
+    if (cursor.indent > keyColumn)
+        return parseCursorBlock(cursor, cursor.indent, ctx, baseLine, builder);
+    if (cursor.indent === keyColumn && isSequenceItem(cursor))
+        return parseCursorBlock(cursor, keyColumn, ctx, baseLine, builder, true);
+    return null;
+};
 const cursorAfterDash = (cursor) => {
     const start = cursor.contentStart;
     const end = cursor.lineEnd;
@@ -127,12 +163,19 @@ const cursorAfterDash = (cursor) => {
         content++;
     return cursor.source.slice(content, end);
 };
+/** 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}" (an unquoted key has letters, digits, "_", "-" and ":" only; quote any other)`,
+});
 /** Shared block grammar consuming one mutable physical-line cursor. */
-const parseCursorBlock = (cursor, baseIndent, ctx, baseLine, builder) => {
-    const wantSource = builder === positionedBuilder;
+const parseCursorBlock = (cursor, baseIndent, ctx, baseLine, builder, compact = false) => {
+    const wantSource = builder.positions === true;
     let items = null;
     let entries = null;
     let pendingItem = null;
+    // the column of the pending object item's keys: its first key's, after `- ` (§7.2)
+    let pendingColumn = 0;
     const startLine = cursor.lineIndex;
     while (cursor.valid) {
         const line = baseLine + cursor.lineIndex;
@@ -145,14 +188,30 @@ const parseCursorBlock = (cursor, baseIndent, ctx, baseLine, builder) => {
             break;
         if (indent > baseIndent) {
             const trimmed = cursorContent(cursor);
+            // §7.2: an object item's keys stand at its first key's column. A line less indented ends the item (§7.1
+            // rule 4); a deeper one, which no nested block took, is inconsistently indented (rule 5) and the item goes on
+            if (pendingItem !== null && indent < pendingColumn) {
+                items.push(builder.mapping(pendingItem, line));
+                pendingItem = null;
+            }
+            if (pendingItem !== null && indent > pendingColumn) {
+                if (ctx.strict)
+                    throw new LimaError({ code: 'INVALID_INDENTATION', line,
+                        message: `Lima: unexpected indentation at line ${line}: "${trimmed}"` });
+                cursor.next();
+                continue;
+            }
             if (items !== null && pendingItem !== null) {
                 const bareKey = trimmed.charCodeAt(trimmed.length - 1) === 58;
                 const colonPos = bareKey && trimmed.indexOf(' ') === -1 ? -1 : findKeySep(trimmed);
                 const keyRaw = colonPos !== -1
-                    ? trimSlice(trimmed, 0, colonPos)
-                    : bareKey ? trimSlice(trimmed, 0, trimmed.length - 1) : '';
+                    ? trimEndSlice(trimmed, 0, colonPos)
+                    : bareKey ? trimEndSlice(trimmed, 0, trimmed.length - 1) : '';
                 if (keyRaw !== '' && !isValidKey(keyRaw)) {
-                    // §5.1: not a usable key — skipped in both modes, as at the top level.
+                    // §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)
+                        throw unrecognizedKeyLine(line, trimmed);
                     cursor.next();
                 }
                 else if (colonPos !== -1) {
@@ -163,19 +222,15 @@ const parseCursorBlock = (cursor, baseIndent, ctx, baseLine, builder) => {
                     if (raw !== '|' && raw.includes('#'))
                         raw = stripComment(raw);
                     const valueCol = wantSource ? cursor.indent + colonPos + 2 + leadingWsLen(trimmed.slice(colonPos + 2)) : 0;
-                    builder.setMapping(pendingItem, key, inlineOrBlockScalar(raw, indent, line, valueCol, rawUndecoded, cursor, ctx, builder));
+                    builder.setMapping(pendingItem, key, inlineOrBlockScalar(raw, rawUndecoded === '|', indent, line, valueCol, rawUndecoded, cursor, ctx, builder));
                 }
                 else if (bareKey) {
                     const key = stripKeyQuotes(keyRaw, ctx.strict, line);
                     checkKeyLength(key, line);
                     cursor.next();
                     skipEmptyAndCommentLines(cursor);
-                    if (cursor.valid && cursor.indent > indent) {
-                        const nested = parseCursorBlock(cursor, cursor.indent, ctx, baseLine, builder);
-                        builder.setMapping(pendingItem, key, nested ?? builder.null(line));
-                    }
-                    else
-                        builder.setMapping(pendingItem, key, builder.null(line));
+                    const nested = blockOfBareKey(cursor, indent, ctx, baseLine, builder);
+                    builder.setMapping(pendingItem, key, nested ?? builder.null(line));
                 }
                 else {
                     if (ctx.strict)
@@ -192,13 +247,16 @@ const parseCursorBlock = (cursor, baseIndent, ctx, baseLine, builder) => {
             }
             continue;
         }
-        if (cursor.firstCode === 45) {
+        // a sequence at its key's column ends at that column's first line that is no item (Core 1.1 §7.2)
+        if (compact && !isSequenceItem(cursor))
+            break;
+        if (isSequenceItem(cursor)) {
             if (pendingItem !== null) {
                 items.push(builder.mapping(pendingItem, line));
                 pendingItem = null;
             }
-            if (items === null)
-                items = [];
+            // a block is a mapping or a sequence, as its first line decides; in non-strict mode a line of the other kind
+            // is skipped, and what the block holds stays (Core 1.1 §7.1)
             if (entries !== null) {
                 if (ctx.strict)
                     throw new LimaError({ code: 'INVALID_INDENTATION', line,
@@ -206,6 +264,8 @@ const parseCursorBlock = (cursor, baseIndent, ctx, baseLine, builder) => {
                 cursor.next();
                 continue;
             }
+            if (items === null)
+                items = [];
             const afterDashRaw = cursorAfterDash(cursor);
             let afterDash = afterDashRaw;
             if (afterDash.includes('#'))
@@ -216,19 +276,33 @@ const parseCursorBlock = (cursor, baseIndent, ctx, baseLine, builder) => {
                 raw: physicalRaw(afterDashRaw), line, col: afterDashCol, tabAdjust: afterDashTab,
             }) : undefined;
             const first = afterDash.charCodeAt(0);
-            if (first !== 34 && first !== 39 && first !== 45 && first !== 123 &&
+            // an item's value is an inline value (§15.3): a flow mapping, or what an unclosed one falls back to (§7.5); a
+            // flow sequence there is a sequence in a sequence (§7.2)
+            if (first === 123) {
+                items.push(parseFlowOrScalarValue(afterDash, ctx, line, builder, dashSource));
+                cursor.next();
+                continue;
+            }
+            if (first === 91) {
+                const sequence = parseFlowSequence(afterDash, ctx, line, builder, dashSource);
+                if (sequence === null)
+                    items.push(parseFlowOrScalarValue(afterDash, ctx, line, builder, dashSource));
+                else if (ctx.strict)
+                    throw new LimaError({ code: 'INVALID_FLOW_SYNTAX', line,
+                        message: `Lima: nested sequence at line ${line}: "${cursorContent(cursor)}"` });
+                else
+                    items.push(builder.null(line));
+                cursor.next();
+                continue;
+            }
+            if (first !== 34 && first !== 39 && first !== 45 &&
                 afterDash.indexOf(': ') === -1 && !afterDash.endsWith(':')) {
                 items.push(parseQuotedOrTyped(afterDash, ctx, line, builder, dashSource));
                 cursor.next();
                 continue;
             }
-            const flowMap = parseFlowMapping(afterDash, ctx, line, builder, dashSource);
             const colonPos = findKeySep(afterDash);
-            if (flowMap !== null) {
-                items.push(flowMap);
-                cursor.next();
-            }
-            else if (afterDash === '-' || DASH_PREFIX_RE.test(afterDash)) {
+            if (afterDash === '-' || DASH_PREFIX_RE.test(afterDash)) {
                 if (ctx.strict)
                     throw new LimaError({ code: 'INVALID_INDENTATION', line,
                         message: `Lima: nested block sequence at line ${line}: "${cursorContent(cursor)}"` });
@@ -255,18 +329,20 @@ const parseCursorBlock = (cursor, baseIndent, ctx, baseLine, builder) => {
                     ? afterDash.slice(valueStart) : trimSlice(afterDash, valueStart, afterDash.length);
                 // The key sits after `- `, two columns past the dash.
                 const valueCol = wantSource ? afterDashCol + valueStart + leadingWsLen(afterDash.slice(valueStart)) : 0;
-                pendingItem = builder.createMappingWith(key, inlineOrBlockScalar(raw, baseIndent + 2, line, valueCol, wantSource ? afterDashRaw.slice(valueStart) : raw, cursor, ctx, builder));
-                while (cursor.valid && cursor.indent > baseIndent) {
+                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));
+                // 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;
                     const ckeyIndent = cursor.asciiIndent;
                     const cfirst = cursor.source.charCodeAt(cursor.contentStart);
                     if (cfirst === 35)
                         break;
-                    const contLine = trimSlice(cursor.source, cursor.contentStart, cursor.lineEnd);
+                    const contLine = trimEndSlice(cursor.source, cursor.contentStart, cursor.lineEnd);
                     const csep = findKeySep(contLine);
                     if (csep === -1)
                         break;
-                    const ckeyRaw = trimSlice(contLine, 0, csep);
+                    const ckeyRaw = trimEndSlice(contLine, 0, csep);
                     if (!isValidKey(ckeyRaw))
                         break;
                     const ckey = stripKeyQuotes(ckeyRaw, ctx.strict, continuationLine);
@@ -280,7 +356,7 @@ const parseCursorBlock = (cursor, baseIndent, ctx, baseLine, builder) => {
                     // contLine starts exactly at contentStart (no leading trim), so
                     // the value's column is the indent plus its offset in contLine.
                     const cValueCol = wantSource ? cursor.indent + csep + 2 + leadingWsLen(contLine.slice(csep + 2)) : 0;
-                    builder.setMapping(pendingItem, ckey, inlineOrBlockScalar(value, ckeyIndent, continuationLine, cValueCol, valueUndecoded, cursor, ctx, builder));
+                    builder.setMapping(pendingItem, ckey, inlineOrBlockScalar(value, valueUndecoded === '|', ckeyIndent, continuationLine, cValueCol, valueUndecoded, cursor, ctx, builder));
                 }
             }
             else if (afterDash.endsWith(':') && isValidKey(trimSlice(afterDash, 0, afterDash.length - 1))) {
@@ -297,12 +373,9 @@ const parseCursorBlock = (cursor, baseIndent, ctx, baseLine, builder) => {
                 keyColumn -= cursor.lineStart;
                 cursor.next();
                 skipEmptyAndCommentLines(cursor);
-                if (cursor.valid && cursor.indent > keyColumn) {
-                    const nested = parseCursorBlock(cursor, cursor.indent, ctx, baseLine, builder);
-                    pendingItem = builder.createMappingWith(key, nested ?? builder.null(line));
-                }
-                else
-                    pendingItem = builder.createMappingWith(key, builder.null(line));
+                const nested = blockOfBareKey(cursor, keyColumn, ctx, baseLine, builder);
+                pendingColumn = keyColumn;
+                pendingItem = builder.createMappingWith(key, nested ?? builder.null(line));
             }
             else {
                 // A quoted-or-typed scalar item — parseQuotedOrTyped enforces
@@ -323,11 +396,13 @@ const parseCursorBlock = (cursor, baseIndent, ctx, baseLine, builder) => {
             const bareKey = trimmed.charCodeAt(trimmed.length - 1) === 58;
             const colonPos = bareKey && trimmed.indexOf(' ') === -1 ? -1 : findKeySep(trimmed);
             const keyRaw = colonPos !== -1
-                ? trimSlice(trimmed, 0, colonPos)
-                : bareKey ? trimSlice(trimmed, 0, trimmed.length - 1) : '';
+                ? trimEndSlice(trimmed, 0, colonPos)
+                : bareKey ? trimEndSlice(trimmed, 0, trimmed.length - 1) : '';
             if (keyRaw !== '' && !isValidKey(keyRaw)) {
-                // §5.1: not a usable key — unrecognised line, skipped in both
-                // modes (§10's strict list is closed and does not cover this).
+                // §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)
+                    throw unrecognizedKeyLine(line, trimmed);
                 cursor.next();
             }
             else if (colonPos !== -1) {
@@ -342,7 +417,7 @@ const parseCursorBlock = (cursor, baseIndent, ctx, baseLine, builder) => {
                 if (raw !== '|' && raw.includes('#'))
                     raw = stripComment(raw);
                 const valueCol = wantSource ? cursor.indent + colonPos + 2 + leadingWsLen(trimmed.slice(colonPos + 2)) : 0;
-                builder.setMapping(entries, key, inlineOrBlockScalar(raw, baseIndent, line, valueCol, rawUndecoded, cursor, ctx, builder));
+                builder.setMapping(entries, key, inlineOrBlockScalar(raw, rawUndecoded === '|', baseIndent, line, valueCol, rawUndecoded, cursor, ctx, builder));
             }
             else if (bareKey) {
                 if (entries === null)
@@ -353,12 +428,8 @@ const parseCursorBlock = (cursor, baseIndent, ctx, baseLine, builder) => {
                     checkDuplicateKey(builder.hasMappingKey(entries, key), key, line, ctx);
                 cursor.next();
                 skipEmptyAndCommentLines(cursor);
-                if (cursor.valid && cursor.indent > baseIndent) {
-                    const nested = parseCursorBlock(cursor, cursor.indent, ctx, baseLine, builder);
-                    builder.setMapping(entries, key, nested ?? builder.null(line));
-                }
-                else
-                    builder.setMapping(entries, key, builder.null(line));
+                const nested = blockOfBareKey(cursor, baseIndent, ctx, baseLine, builder);
+                builder.setMapping(entries, key, nested ?? builder.null(line));
             }
             else {
                 if (ctx.strict)
@@ -381,7 +452,10 @@ export const parseBlockRange = (source, start, end, ctx, baseLine, builder, dept
     if (!cursor.valid)
         return null;
     const baseIndent = cursor.asciiIndent;
-    const value = parseCursorBlock(cursor, baseIndent, ctx, baseLine, builder);
+    // Core 1.1 §7.2: at the top level's own column 0 only a sequence is the key's block; any other first line is not
+    if (baseIndent === 0 && !isSequenceItem(cursor))
+        return null;
+    const value = parseCursorBlock(cursor, baseIndent, ctx, baseLine, builder, baseIndent === 0);
     // Recursive block containers require strictly increasing integer
     // indentation. At one indentation level a sequence-item mapping can add
     // one container and Core flow syntax at most two more, so delta + 4 is a

package/dist/builder.d.ts

@@ -26,6 +26,8 @@
  */
 import type { ReferenceSource } from './reference-tokens2.js';
 export interface ValueBuilder<V, M = Map<string, V>> {
+    /** Whether scalar builders need physical source anchors for editor positions. */
+    readonly positions?: boolean;
     null(line: number): V;
     bool(value: boolean, line: number): V;
     int(value: number, line: number): V;

package/dist/core.d.ts

@@ -1,5 +1,5 @@
 /**
- * Lima Core 1.0 parser — reference-unaware by construction (Appendix B:
+ * Lima Core 1.1 parser — reference-unaware by construction (Appendix B:
  * reference resolution is exclusively the concern of the optional
  * References extension). `($key)`/`(%key)`-shaped text is never
  * recognised or coerced here; it simply falls through as an ordinary
@@ -22,6 +22,7 @@ import { type LimaValue } from './value.js';
 import { type ParseContext, type Diagnostic } from './normalize.js';
 import { type PositionedValue } from './scalars.js';
 import type { ValueBuilder } from './builder.js';
+import type { ReferenceToken2 } from './reference-tokens2.js';
 export type { Diagnostic, ParseContext } from './normalize.js';
 export { NESTING_DEPTH_LIMIT, SCALAR_LENGTH_LIMIT } from './normalize.js';
 export type { PositionedValue, InsertedAt } from './scalars.js';
@@ -33,13 +34,23 @@ export type CoreOptions = {
     onWarning?: (diagnostic: Diagnostic) => void;
 };
 /**
- * Parses Lima Core 1.0 syntax into the internal annotated value tree —
+ * Parses Lima Core 1.1 syntax into the internal annotated value tree —
  * every node carrying its source line, string leaves additionally carrying
  * whether they came from quoted syntax. `($key)`/`(%key)` text is left
  * exactly as written; nothing here ever inspects or resolves it. The
  * primitive the References layer (`references.ts`) builds on.
  */
 export declare const parseCoreWithPositions: (frontMatter: string, ctx: ParseContext) => Map<string, PositionedValue>;
+export type PositionedReferenceParse = {
+    document: Map<string, PositionedValue>;
+    references: ReferenceToken2[];
+};
+/**
+ * Position-aware Core parse plus every active References 2.0 token seen while
+ * values are built. Recording at construction time preserves tokens from
+ * earlier duplicate-key values even though the result map is last-value-wins.
+ */
+export declare const parseCoreWithPositionedReferences: (frontMatter: string, ctx: ParseContext) => PositionedReferenceParse;
 /** The public result shape (Core §11.1): every value `toNative*` can produce. */
 export type NativeValue = null | boolean | number | string | Date | NativeValue[] | {
     [key: string]: NativeValue;
@@ -64,7 +75,7 @@ export declare const toNative: (v: LimaValue) => NativeValue;
  */
 export declare const toNativeFromPositioned: (v: PositionedValue) => NativeValue;
 /**
- * Public Core 1.0 entry point. Never resolves `($key)`/`(%key)` text — see
+ * Public Core 1.1 entry point. Never resolves `($key)`/`(%key)` text — see
  * the module doc comment. Equivalent in observable behavior to calling
  * `parseReferences()` with no partials on a document that happens to
  * contain no references, except that here reference-shaped text is

package/dist/core.js

@@ -1,5 +1,5 @@
 /**
- * Lima Core 1.0 parser — reference-unaware by construction (Appendix B:
+ * Lima Core 1.1 parser — reference-unaware by construction (Appendix B:
  * reference resolution is exclusively the concern of the optional
  * References extension). `($key)`/`(%key)`-shaped text is never
  * recognised or coerced here; it simply falls through as an ordinary
@@ -20,11 +20,13 @@
  */
 import { checkKeyLength, byteLength, DOCUMENT_SIZE_LIMIT, TOP_LEVEL_KEY_LIMIT, NESTING_DEPTH_LIMIT, } from './normalize.js';
 import { unescapeDQ, stripComment, stripCommentKeepEscapes, positionedBuilder, NO_SPAN_VALUE, parseSimpleScalarSpan, } from './scalars.js';
+import { isTrimWhitespace } from './chars.js';
 import { parseFlowOrScalarValue } from './flow.js';
 import { parseBlockRange } from './block.js';
 import { buildBlockScalar } from './block-scalar.js';
 import { LimaError } from './errors.js';
 import { KeyCursor, scanKeys } from './scanner.js';
+import { checkRangeLines, isBlockScalarMarker } from './structure.js';
 export { NESTING_DEPTH_LIMIT, SCALAR_LENGTH_LIMIT } from './normalize.js';
 export { toPlainValue } from './scalars.js';
 /** Every Lima mapping result must be a prototype-free object (Core §11.1). */
@@ -76,7 +78,7 @@ const lineAt = (s, pos) => {
     return n;
 };
 /**
- * Parses Lima Core 1.0 syntax, generic over the output representation
+ * Parses Lima Core 1.1 syntax, generic over the output representation
  * (`builder` — see `builder.ts`): References needs the annotated
  * `PositionedValue` tree (`parseCoreWithPositions` below fixes `V` to
  * that), while `parseCore` fixes `V` to the public native shape directly,
@@ -156,8 +158,21 @@ const parseCoreGeneric = (frontMatter, ctx, builder, computeDepth) => {
             searchFrom = lineEnd + 1;
         }
     }
-    const parseEntry = (key, line, rawStart, isBlock, inlineEnd, nextStart) => {
+    const parseEntry = (key, line, separatorEnd, isBlock, inlineEnd, nextStart) => {
         checkKeyLength(key, line);
+        // §4 step 3: an inline value begins after the spaces that follow `: `, however many there are — as in a
+        // block mapping (block.ts trimSlice), so that the scalar paths below and the source column see the value
+        // itself. The newline that ends the line is not skipped.
+        let rawStart = separatorEnd;
+        if (!isBlock) {
+            while (rawStart < nextStart) {
+                const c = frontMatter.charCodeAt(rawStart);
+                // printable ASCII other than SPACE is never whitespace: the common case ends here at once
+                if ((c > 0x20 && c < 0x7f) || c === 10 || !isTrimWhitespace(c))
+                    break;
+                rawStart++;
+            }
+        }
         if ((strict || ctx.onWarning !== undefined) && builder.hasMappingKey(root, key)) {
             const diagnostic = {
                 code: 'DUPLICATE_KEY', line, key,
@@ -172,11 +187,23 @@ const parseCoreGeneric = (frontMatter, ctx, builder, computeDepth) => {
         }
         const firstNewline = inlineEnd ?? frontMatter.indexOf('\n', rawStart);
         const newlineInRange = firstNewline < nextStart;
+        // §6.1.5: `|` alone is a literal block scalar marker, with a body or without one (then its value is empty).
+        // The introducing key is at column 0; `buildBlockScalar` finds the scalar's own extent within the range (which
+        // runs to the next top-level key), so a dedented comment or dedented freetext before that key ends the scalar
+        // rather than being absorbed into it.
+        if (!isBlock && frontMatter.charCodeAt(rawStart) === 124) {
+            const markerEnd = newlineInRange && firstNewline >= 0 ? firstNewline : nextStart;
+            if (frontMatter.slice(rawStart, markerEnd).trim() === '|') {
+                const bodyLines = markerEnd < nextStart ? frontMatter.slice(markerEnd + 1, nextStart).split('\n') : [];
+                builder.setMapping(root, key, buildBlockScalar(bodyLines, 0, line, ctx, builder).value);
+                return;
+            }
+        }
         // Physical codepoint column of the value's first character in its
         // source line — the anchor for References 2.0 token positions (§2.4).
         // References 2.0 token positions (§2.4): only build the source anchor
         // for the annotated builder; `parseCore` (native) discards it.
-        const wantSource = builder === positionedBuilder;
+        const wantSource = builder.positions === true;
         const valueLineStart = wantSource ? frontMatter.lastIndexOf('\n', rawStart - 1) + 1 : 0;
         const valueCol = wantSource ? [...frontMatter.slice(valueLineStart, rawStart)].length : 0;
         const lineTabAdjust = wantSource && ctx.tabAdjust ? [ctx.tabAdjust[line - 1] ?? 0] : undefined;
@@ -218,31 +245,18 @@ const parseCoreGeneric = (frontMatter, ctx, builder, computeDepth) => {
                 lineStart = j + 1;
             }
         }
-        {
-            if (lines.length === 0) {
-                builder.setMapping(root, key, builder.null(line));
-                return;
-            }
-            const line0Trimmed = lines[0].trim();
-            if (lines.length === 1 || line0Trimmed !== '|') {
-                const line0 = lines[0];
-                const hasHash = line0.includes('#');
-                const val = hasHash ? stripComment(line0) : line0;
-                const source = wantSource ? {
-                    raw: hasHash ? stripCommentKeepEscapes(line0) : line0,
-                    line, col: valueCol, tabAdjust: lineTabAdjust,
-                } : undefined;
-                builder.setMapping(root, key, parseFlowOrScalarValue(val, ctx, line, builder, source));
-                return;
-            }
-            // Multi-line string (`|` literal block scalar). The introducing key
-            // is at column 0 here; `buildBlockScalar` finds the scalar's own
-            // extent within the range (which runs to the next top-level key),
-            // so a dedented comment or dedented freetext before that key ends
-            // the scalar rather than being absorbed into it.
-            const bodyLines = raw.slice(raw.indexOf('\n') + 1).split('\n');
-            builder.setMapping(root, key, buildBlockScalar(bodyLines, 0, line, ctx, builder).value);
+        if (lines.length === 0) {
+            builder.setMapping(root, key, builder.null(line));
+            return;
         }
+        const line0 = lines[0];
+        const hasHash = line0.includes('#');
+        const val = hasHash ? stripComment(line0) : line0;
+        const source = wantSource ? {
+            raw: hasHash ? stripCommentKeepEscapes(line0) : line0,
+            line, col: valueCol, tabAdjust: lineTabAdjust,
+        } : undefined;
+        builder.setMapping(root, key, parseFlowOrScalarValue(val, ctx, line, builder, source));
     };
     // A recognised top-level entry needs at least one UTF-16 unit of key text,
     // `:`, and its terminating newline: three units. Consequently 129 entries
@@ -279,6 +293,9 @@ const parseCoreGeneric = (frontMatter, ctx, builder, computeDepth) => {
     else {
         const matches = scanKeys(frontMatter);
         const keyCount = matches.length;
+        // Core 1.1: before the first key no line belongs to any structure (structure.ts)
+        if (strict)
+            checkRangeLines(frontMatter, 0, keyCount === 0 ? frontMatter.length : matches[0].matchStart, 1, 'none');
         if (keyCount === 0)
             return root;
         if (keyCount > TOP_LEVEL_KEY_LIMIT) {
@@ -291,8 +308,19 @@ const parseCoreGeneric = (frontMatter, ctx, builder, computeDepth) => {
             const m = matches[i];
             const rawDQ = m.doubleQuotedRaw;
             const key = m.unquoted ?? m.singleQuoted ?? (rawDQ !== undefined ? unescapeDQ(rawDQ, strict, m.line) : undefined);
+            const nextStart = i + 1 < keyCount ? matches[i + 1].matchStart : frontMatter.length;
             if (key !== undefined)
-                parseEntry(key, m.line, m.rawStart, m.isBlock, m.inlineEnd, i + 1 < keyCount ? matches[i + 1].matchStart : frontMatter.length);
+                parseEntry(key, m.line, m.rawStart, m.isBlock, m.inlineEnd, nextStart);
+            // Core 1.1: the lines after the key's own line, up to the next key, belong to its block or to nothing
+            if (strict) {
+                const lineEnd = m.isBlock ? m.rawStart - 1 : (m.inlineEnd ?? frontMatter.indexOf('\n', m.rawStart));
+                // no line after the key's own one: nothing to check, the usual case
+                if (lineEnd !== -1 && lineEnd + 1 < nextStart) {
+                    const owner = m.isBlock ? 'mapping'
+                        : isBlockScalarMarker(frontMatter, m.rawStart, lineEnd) ? 'scalar' : 'inline';
+                    checkRangeLines(frontMatter, lineEnd + 1, nextStart, m.line + 1, owner, m.rawStart, lineEnd);
+                }
+            }
         }
     }
     // Core §9 nesting depth, over Core's own reference-inert tree. When
@@ -308,13 +336,35 @@ const parseCoreGeneric = (frontMatter, ctx, builder, computeDepth) => {
     return root;
 };
 /**
- * Parses Lima Core 1.0 syntax into the internal annotated value tree —
+ * Parses Lima Core 1.1 syntax into the internal annotated value tree —
  * every node carrying its source line, string leaves additionally carrying
  * whether they came from quoted syntax. `($key)`/`(%key)` text is left
  * exactly as written; nothing here ever inspects or resolves it. The
  * primitive the References layer (`references.ts`) builds on.
  */
 export const parseCoreWithPositions = (frontMatter, ctx) => parseCoreGeneric(frontMatter, ctx, positionedBuilder, depthOfPositioned);
+/**
+ * Position-aware Core parse plus every active References 2.0 token seen while
+ * values are built. Recording at construction time preserves tokens from
+ * earlier duplicate-key values even though the result map is last-value-wins.
+ */
+export const parseCoreWithPositionedReferences = (frontMatter, ctx) => {
+    const references = [];
+    const recordingBuilder = {
+        ...positionedBuilder,
+        string: (value, line, quoted, source) => {
+            const positioned = positionedBuilder.string(value, line, quoted, source);
+            if (positioned.kind === 'string' && positioned.references2) {
+                references.push(...positioned.references2);
+            }
+            return positioned;
+        },
+    };
+    return {
+        document: parseCoreGeneric(frontMatter, ctx, recordingBuilder, depthOfPositioned),
+        references,
+    };
+};
 /**
  * The `ValueBuilder<NativeValue>` — `parseCore`'s fast path. Every scalar
  * builder is the identity function: unlike `positionedBuilder`, there is no
@@ -402,7 +452,7 @@ export const toNativeFromPositioned = (v) => {
     }
 };
 /**
- * Public Core 1.0 entry point. Never resolves `($key)`/`(%key)` text — see
+ * Public Core 1.1 entry point. Never resolves `($key)`/`(%key)` text — see
  * the module doc comment. Equivalent in observable behavior to calling
  * `parseReferences()` with no partials on a document that happens to
  * contain no references, except that here reference-shaped text is

package/dist/errors.d.ts

@@ -8,7 +8,7 @@
  * module directly rather than duplicating it) inspect *why* a parse failed
  * without re-parsing the message string.
  */
-export type LimaDiagnosticCode = 'INVALID_ESCAPE' | 'INVALID_QUOTE' | 'INVALID_DATE' | 'INVALID_NUMBER' | 'INVALID_REFERENCE_SHAPE' | 'INVALID_INDENTATION' | 'INVALID_FLOW_SYNTAX' | 'DUPLICATE_KEY' | 'RESOURCE_LIMIT' | 'UNRESOLVED_REFERENCE' | 'INVALID_INTERPOLATION' | 'INVALID_PARTIAL';
+export type LimaDiagnosticCode = 'INVALID_ESCAPE' | 'INVALID_QUOTE' | 'INVALID_DATE' | 'INVALID_NUMBER' | 'INVALID_REFERENCE_SHAPE' | 'INVALID_INDENTATION' | 'UNRECOGNIZED_LINE' | 'INVALID_FLOW_SYNTAX' | 'DUPLICATE_KEY' | 'RESOURCE_LIMIT' | 'UNRESOLVED_REFERENCE' | 'INVALID_INTERPOLATION' | 'INVALID_PARTIAL';
 export interface LimaDiagnostic {
     code: LimaDiagnosticCode;
     message: string;

package/dist/index.d.ts

@@ -3,7 +3,7 @@
  *
  * Public entry point. The implementation is split per Appendix B's own
  * layering:
- *   - `core.ts`       — Lima Core 1.0, reference-unaware by construction.
+ *   - `core.ts`       — Lima Core 1.1, reference-unaware by construction.
  *   - `references2.ts` — the References 2.0 extension layered on Core.
  *   - `references.ts`  — the frozen internal References 1.0 implementation.
  *   - `value.ts`       — the shared Lima Value Model both build on.

package/dist/index.js

@@ -3,7 +3,7 @@
  *
  * Public entry point. The implementation is split per Appendix B's own
  * layering:
- *   - `core.ts`       — Lima Core 1.0, reference-unaware by construction.
+ *   - `core.ts`       — Lima Core 1.1, reference-unaware by construction.
  *   - `references2.ts` — the References 2.0 extension layered on Core.
  *   - `references.ts`  — the frozen internal References 1.0 implementation.
  *   - `value.ts`       — the shared Lima Value Model both build on.

package/dist/reference-tokens2.d.ts

@@ -39,5 +39,13 @@ export type ReferenceSource = {
     col: number;
     tabAdjust?: number[];
 };
+export declare const SEGMENT = "[a-zA-Z0-9_][a-zA-Z0-9_:-]*";
+export declare const DOC_PATH = "[a-zA-Z0-9_][a-zA-Z0-9_:-]*(?:\\.[a-zA-Z0-9_][a-zA-Z0-9_:-]*)*";
+export declare const PARTIAL_NAME = "[a-zA-Z0-9_][a-zA-Z0-9_:/-]*";
+export declare const PARTIAL_PATH = "[a-zA-Z0-9_][a-zA-Z0-9_:/-]*(?:\\.[a-zA-Z0-9_][a-zA-Z0-9_:-]*)*";
 export declare const PURE_REFERENCE_2: RegExp;
+/** Converts a 0-based codepoint offset to JavaScript/LSP UTF-16 units. */
+export declare const codepointOffsetToUtf16: (text: string, codepointOffset: number) => number;
+/** Converts a 0-based JavaScript/LSP UTF-16 offset to a codepoint offset. */
+export declare const utf16OffsetToCodepoint: (text: string, utf16Offset: number) => number;
 export declare const scanReferenceTokens2: (value: string, source: ReferenceSource | undefined) => ReferenceToken2[];

package/dist/reference-tokens2.js

@@ -1,20 +1,42 @@
 /** Reference tokens recorded while the annotated Core tree is being built. */
-const SEGMENT = '[a-zA-Z0-9_][a-zA-Z0-9_:-]*';
-const DOC_PATH = `${SEGMENT}(?:\\.${SEGMENT})*`;
-const PARTIAL_NAME = '[a-zA-Z0-9_][a-zA-Z0-9_:/-]*';
-const PARTIAL_PATH = `${PARTIAL_NAME}(?:\\.${SEGMENT})*`;
+export const SEGMENT = '[a-zA-Z0-9_][a-zA-Z0-9_:-]*';
+export const DOC_PATH = `${SEGMENT}(?:\\.${SEGMENT})*`;
+export const PARTIAL_NAME = '[a-zA-Z0-9_][a-zA-Z0-9_:/-]*';
+export const PARTIAL_PATH = `${PARTIAL_NAME}(?:\\.${SEGMENT})*`;
 export const PURE_REFERENCE_2 = new RegExp(`^(?:\\$\\{(${DOC_PATH})\\}|\\$\\((${PARTIAL_PATH})\\))$`);
 const REFERENCE_2 = new RegExp(`\\$\\{(${DOC_PATH})\\}|\\$\\((${PARTIAL_PATH})\\)`, 'g');
 const NO_TOKENS = [];
+const utf16WidthAt = (text, offset) => text.codePointAt(offset) > 0xffff ? 2 : 1;
 /** Codepoint length of the UTF-16 slice `[a, b)` of `s`. */
 const codepointLen = (s, a, b) => {
     let n = 0;
     for (let i = a; i < b;) {
-        i += s.codePointAt(i) > 0xffff ? 2 : 1;
+        i += utf16WidthAt(s, i);
         n++;
     }
     return n;
 };
+/** Converts a 0-based codepoint offset to JavaScript/LSP UTF-16 units. */
+export const codepointOffsetToUtf16 = (text, codepointOffset) => {
+    let utf16Offset = 0;
+    let codepoints = 0;
+    while (utf16Offset < text.length && codepoints < codepointOffset) {
+        utf16Offset += utf16WidthAt(text, utf16Offset);
+        codepoints++;
+    }
+    return utf16Offset;
+};
+/** Converts a 0-based JavaScript/LSP UTF-16 offset to a codepoint offset. */
+export const utf16OffsetToCodepoint = (text, utf16Offset) => {
+    let currentUtf16 = 0;
+    let codepoints = 0;
+    const limit = Math.min(Math.max(utf16Offset, 0), text.length);
+    while (currentUtf16 < limit) {
+        currentUtf16 += utf16WidthAt(text, currentUtf16);
+        codepoints++;
+    }
+    return codepoints;
+};
 /** Splice points (decoded value order): token text, UTF-16 index, path. */
 const scanDecoded = (value) => {
     REFERENCE_2.lastIndex = 0;

package/dist/references2.d.ts

@@ -1,5 +1,19 @@
-import { type Diagnostic } from './core.js';
+import { type Diagnostic, type PositionedReferenceParse, type PositionedValue } from './core.js';
 type Meta = Record<string, unknown>;
+/**
+ * Resolve one document-reference path with the same traversal, cycle checks,
+ * and edge budget used by the public References 2.0 parser. The returned
+ * positioned value retains the definition site's source line.
+ */
+export type DocumentReferenceTargetResolution = {
+    status: 'resolved';
+    target: PositionedValue;
+} | {
+    status: 'unverifiable-partials';
+} | {
+    status: 'unresolved';
+};
+export declare const resolveDocumentReferenceTarget: (parsed: PositionedReferenceParse, path: string) => DocumentReferenceTargetResolution;
 export type ParseMode = 'references' | 'core';
 export type ParseOptions = {
     mode?: ParseMode;

package/dist/references2.js

@@ -7,6 +7,10 @@ import { collectAllParticipants, deepCopyPositioned, earliestParticipant, emptyM
 const PARTIAL_NAME = '[a-zA-Z0-9_][a-zA-Z0-9_:/-]*';
 const PARTIAL_NAME_RE = new RegExp(`^${PARTIAL_NAME}$`);
 const MAX_EDGES = 3;
+// Looking up the root path is itself the first reference edge; recursion into
+// that root therefore gets the public resolver's remaining two-edge budget.
+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) => {
@@ -44,6 +48,91 @@ const documentTarget = (root, path) => {
     }
     return { root: value, tail: segments.slice(index) };
 };
+export const resolveDocumentReferenceTarget = (parsed, path) => {
+    const { document } = parsed;
+    const target = documentTarget(document, path);
+    if (target === undefined)
+        return { status: 'unresolved' };
+    const resourceStatus = documentReferenceResourceStatus(parsed);
+    if (resourceStatus === 'unverifiable-partials')
+        return { status: resourceStatus };
+    if (resourceStatus === 'invalid')
+        return { status: 'unresolved' };
+    const ctx = { diagnostics: [], cache: 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)
+        return { status: 'unresolved' };
+    const selected = lookupPath(resolved.value, target.tail);
+    return selected === undefined
+        ? { status: 'unresolved' }
+        : { status: 'resolved', target: selected };
+};
+const resolveDocument = (document, partials, ctx) => {
+    const resolved = new Map();
+    for (const [key, value] of document) {
+        const stack = new Set([value]);
+        resolved.set(key, resolveNode(value, document, partials, ctx, MAX_EDGES, stack).value);
+    }
+    return resolved;
+};
+const assertResolvedDocumentResourceLimits = (resolved) => {
+    const finalized = [...resolved].map(([key, value]) => [key, finalizePositioned(value)]);
+    const depth = finalized.length === 0 ? 0 : Math.max(...finalized.map(([, value]) => value.depth));
+    if (depth > NESTING_DEPTH_LIMIT) {
+        const participants = finalized
+            .filter(([, value]) => value.depth === depth)
+            .flatMap(([, value]) => value.deepestParticipants);
+        const winner = earliestParticipant(participants);
+        throw new LimaError({
+            code: 'RESOURCE_LIMIT', line: winner?.line ?? 1, token: winner?.token,
+            ...(winner?.offset !== undefined ? { column: winner.offset + 1 } : {}),
+            message: `Lima: nesting depth exceeds maximum of ${NESTING_DEPTH_LIMIT} at line ${winner?.line ?? 1}`,
+        });
+    }
+    let nodeCount = 1;
+    for (const [, value] of finalized)
+        nodeCount += value.nodeCount;
+    if (nodeCount > RESULT_NODE_LIMIT) {
+        const participants = [];
+        for (const value of resolved.values())
+            collectAllParticipants(value, participants);
+        const winner = earliestParticipant(participants);
+        throw 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}`,
+        });
+    }
+    return finalized;
+};
+const documentReferenceResourceStatus = (parsed) => {
+    // Partial values are supplied by caller code and can change whole-document
+    // depth/node limits. With no file convention for them, editor tooling cannot
+    // prove that even an unrelated document reference is safe to resolve.
+    if (parsed.references.some((reference) => reference.partialPath !== undefined))
+        return 'unverifiable-partials';
+    const { document } = parsed;
+    const cached = referenceResourceStatuses.get(document);
+    if (cached !== undefined)
+        return cached;
+    const ctx = { diagnostics: [], cache: new WeakMap() };
+    const resolved = resolveDocument(document, new Map(), ctx);
+    let valid = !ctx.diagnostics.some((diagnostic) => diagnostic.code === 'RESOURCE_LIMIT');
+    if (valid) {
+        try {
+            assertResolvedDocumentResourceLimits(resolved);
+        }
+        catch (error) {
+            if (!(error instanceof LimaError) || error.code !== 'RESOURCE_LIMIT')
+                throw error;
+            valid = false;
+        }
+    }
+    const status = valid ? 'valid' : 'invalid';
+    referenceResourceStatuses.set(document, status);
+    return status;
+};
 const lookupPartial = (partials, path) => {
     const dot = path.indexOf('.');
     if (dot < 0)
@@ -284,11 +373,7 @@ const parseInternal = (frontMatter, options, useResolveCache) => {
     }
     const document = parseCoreWithPositions(frontMatter, { strict: options?.strict ?? false, onWarning: options?.onWarning });
     const ctx = { diagnostics: [], ...(useResolveCache ? { cache: new WeakMap() } : {}) };
-    const resolved = new Map();
-    for (const [key, value] of document) {
-        const stack = new Set([value]);
-        resolved.set(key, resolveNode(value, document, partials, ctx, MAX_EDGES, stack).value);
-    }
+    const resolved = resolveDocument(document, partials, ctx);
     if (options?.strict)
         for (const value of resolved.values())
             scanUnresolved(value, ctx);
@@ -299,31 +384,7 @@ const parseInternal = (frontMatter, options, useResolveCache) => {
         // already do; `offset` was internal-only here.
         throw new LimaError({ ...winner, column: winner.offset + 1 });
     }
-    const finalized = [...resolved].map(([key, value]) => [key, finalizePositioned(value)]);
-    const depth = finalized.length === 0 ? 0 : Math.max(...finalized.map(([, value]) => value.depth));
-    if (depth > NESTING_DEPTH_LIMIT) {
-        const participants = finalized.filter(([, value]) => value.depth === depth).flatMap(([, value]) => value.deepestParticipants);
-        const winner = earliestParticipant(participants);
-        throw new LimaError({
-            code: 'RESOURCE_LIMIT', line: winner?.line ?? 1, token: winner?.token,
-            ...(winner?.offset !== undefined ? { column: winner.offset + 1 } : {}),
-            message: `Lima: nesting depth exceeds maximum of ${NESTING_DEPTH_LIMIT} at line ${winner?.line ?? 1}`,
-        });
-    }
-    let nodeCount = 1;
-    for (const [, value] of finalized)
-        nodeCount += value.nodeCount;
-    if (nodeCount > RESULT_NODE_LIMIT) {
-        const participants = [];
-        for (const value of resolved.values())
-            collectAllParticipants(value, participants);
-        const winner = earliestParticipant(participants);
-        throw 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 finalized = assertResolvedDocumentResourceLimits(resolved);
     const out = emptyMapping();
     for (const [key, value] of finalized)
         out[key] = value.native;

package/dist/scalars.js

@@ -13,6 +13,7 @@ export const hasActiveReferences2 = (value) => value.kind === 'string' ? (value.
         : false;
 /** The `ValueBuilder<PositionedValue>` — reconstructs today's annotated tree exactly, for References. */
 export const positionedBuilder = {
+    positions: true,
     null: (line) => ({ kind: 'null', line }),
     bool: (value, line) => ({ kind: 'bool', value, line }),
     int: (value, line) => ({ kind: 'int', value, line }),

package/dist/scanner.js

@@ -59,6 +59,10 @@ const matchSeparator = (s, pos) => {
         i++; // consume spaces
     if (i < s.length && s.charCodeAt(i) === 10)
         return i + 1;
+    // Core 1.1: the end of the input ends the key's line as a newline does, so a last `key:` is `key: null`, as it
+    // is at any nested level (it was no key at all at the top level before)
+    if (i === s.length)
+        return i;
     // Backtracking a pure-space run can never reveal a `\n` the maximal
     // scan didn't already see (every intermediate position is followed by
     // either another space or the same non-`\n` stop character) — so

package/dist/structure.d.ts

@@ -0,0 +1,13 @@
+/**
+ * What the lines after a key belong to: nothing (`none`, before the first key; `inline`, after an inline value), a
+ * block mapping or sequence (`mapping`, after a bare key) or a `|` scalar (`scalar`).
+ */
+export type RangeOwner = 'none' | 'inline' | 'mapping' | 'scalar';
+/**
+ * Checks the lines of `frontMatter` from `start` (a line start) to `end` that follow a key owned as `owner`; `line`
+ * is the 1-based line at `start`; `valueStart` to `valueEnd` is the inline value of that key, read only for the hint a
+ * YAML marker earns in the error. Throws for the first line that belongs to no structure.
+ */
+export declare function checkRangeLines(frontMatter: string, start: number, end: number, line: number, owner: RangeOwner, valueStart?: number, valueEnd?: number): void;
+/** Whether the inline value that starts at `rawStart` and ends its line at `lineEnd` is a `|` block scalar marker. */
+export declare const isBlockScalarMarker: (frontMatter: string, rawStart: number, lineEnd: number) => boolean;

package/dist/structure.js

@@ -0,0 +1,110 @@
+/**
+ * Core 1.1 §4, §7.1 rule 5 and §10.1: in strict mode every content line belongs to the structure. Between two
+ * top-level keys (and before the first), a line that is neither blank nor a comment is
+ *
+ *   - unrecognised (`UNRECOGNIZED_LINE`) when it starts at column 0: it matches no key pattern, or the scanner would
+ *     have ended the range at it;
+ *     A sequence that starts at column 0 under a bare key is that key's (Core 1.1 §7.2), up to the first line at
+ *     column 0 that is no item.
+ *   - inconsistently indented (`INVALID_INDENTATION`) when it is indented and no block owns it: before the first key;
+ *     after a key with an inline value other than `|`, which opens no block; under a block mapping, but less indented
+ *     than its first line (its base indentation, §7.1 rule 1), where the block parser stops; or after a `|` scalar
+ *     that a line at column 0 ended (§6.1.5).
+ *
+ * The lines a block mapping or a `|` scalar owns are checked where they are parsed. Non-strict mode skips all of
+ * these lines, as Core 1.0 did in both modes.
+ */
+import { isTrimWhitespace } from './chars.js';
+import { LimaError } from './errors.js';
+/**
+ * Checks the lines of `frontMatter` from `start` (a line start) to `end` that follow a key owned as `owner`; `line`
+ * is the 1-based line at `start`; `valueStart` to `valueEnd` is the inline value of that key, read only for the hint a
+ * YAML marker earns in the error. Throws for the first line that belongs to no structure.
+ */
+export function checkRangeLines(frontMatter, start, end, line, owner, valueStart = 0, valueEnd = 0) {
+    let pos = start;
+    let current = line;
+    let base = -1; // a block mapping's base indentation, once its first content line set it
+    let scalarOpen = owner === 'scalar';
+    while (pos < end) {
+        const lineEnd = frontMatter.indexOf('\n', pos);
+        const stop = lineEnd === -1 || lineEnd > end ? end : lineEnd;
+        // positions, not substrings: a line is read out of `frontMatter` only for an error message
+        let spaces = pos;
+        while (spaces < stop && frontMatter.charCodeAt(spaces) === 32)
+            spaces++;
+        const indent = spaces - pos;
+        // §6.1.5: a `|` scalar holds every line up to the first non-empty one at its key's column (0), `#` included
+        if (scalarOpen && (spaces === stop || indent > 0)) {
+            pos = lineEnd + 1;
+            current++;
+            if (lineEnd === -1 || lineEnd >= end)
+                break;
+            continue;
+        }
+        scalarOpen = false;
+        // blank and comment lines by Lima's own whitespace; indentation by ASCII space only (§3 expanded the tabs)
+        let first = pos;
+        while (first < stop && isTrimWhitespace(frontMatter.charCodeAt(first)))
+            first++;
+        if (first < stop && frontMatter.charCodeAt(first) !== 35) {
+            // §7.2: a bare key's sequence may start at its own column, 0 here; it ends at the first line there that is no
+            // item
+            const item = indent === 0 && isItemAt(frontMatter, pos, stop);
+            if (owner === 'mapping' && base === -1 && item)
+                base = 0;
+            if (indent === 0 && !(base === 0 && item)) {
+                const text = frontMatter.slice(pos, stop);
+                throw new LimaError({
+                    code: 'UNRECOGNIZED_LINE', line: current,
+                    message: `Lima: unrecognised line at line ${current}: "${text}"${hint(text)}`,
+                });
+            }
+            if (owner === 'mapping' && base === -1)
+                base = indent;
+            if (indent > 0 && !(owner === 'mapping' && indent >= base)) {
+                throw new LimaError({
+                    code: 'INVALID_INDENTATION', line: current,
+                    message: `Lima: unexpected indentation at line ${current}: "${frontMatter.slice(first, stop)}"${owner === 'inline' ? yamlHint(frontMatter.slice(valueStart, valueEnd).trim()) : ''}`,
+                });
+            }
+        }
+        if (lineEnd === -1 || lineEnd >= end)
+            break;
+        pos = lineEnd + 1;
+        current++;
+    }
+}
+/** Whether the inline value that starts at `rawStart` and ends its line at `lineEnd` is a `|` block scalar marker. */
+export const isBlockScalarMarker = (frontMatter, rawStart, lineEnd) => {
+    let i = rawStart, j = lineEnd;
+    while (i < j && isTrimWhitespace(frontMatter.charCodeAt(i)))
+        i++;
+    while (j > i && isTrimWhitespace(frontMatter.charCodeAt(j - 1)))
+        j--;
+    return j - i === 1 && frontMatter.charCodeAt(i) === 124;
+};
+/** What a reader likely meant by an unrecognised line, as a hint after the message; none for anything else. */
+const hint = (text) => {
+    if (text === '---' || text === '...')
+        return ' (a YAML document marker; Lima has one document)';
+    if (isItem(text))
+        return ' (a sequence item belongs to a key with no value of its own)';
+    if (text.startsWith('"') || text.startsWith("'"))
+        return ' (a quoted key closes on its own line)';
+    // `author Odile`, `key:value`: key characters, but no ": " after them
+    if (!text.includes(':') || /^[a-zA-Z0-9_][a-zA-Z0-9_:-]*$/.test(text.split(' ')[0]))
+        return ' (a key needs ": " after it)';
+    return ' (an unquoted key has letters, digits, "_", "-" and ":" only; quote any other)';
+};
+/** The hint a YAML block scalar marker in place of a value earns; none for any other value. */
+const yamlHint = (value) => {
+    if (value === '>' || value === '>-' || value === '>+')
+        return ` ("${value}" is YAML's folded scalar; Lima writes "|" and continues a line with "^^")`;
+    if (value === '|-' || value === '|+')
+        return ` ("${value}" is a YAML chomping indicator; Lima writes "|")`;
+    return '';
+};
+/** §7.2: `-` alone or `-` followed by whitespace begins a sequence item (Core 1.1); `---` or `-x` does not. */
+const isItemAt = (s, start, end) => s.charCodeAt(start) === 45 && (end - start === 1 || isTrimWhitespace(s.charCodeAt(start + 1)));
+const isItem = (text) => isItemAt(text, 0, text.length);

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@limaformat/lima",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Lima frontmatter parser — LIMA Is Metadata Annotation",
   "keywords": ["frontmatter", "parser", "yaml", "markdown", "metadata"],
   "homepage": "https://limaformat.dev",
   "author": "Michael Kortstiege",
   "repository": {
     "type": "git",
-    "url": "https://github.com/limaformat/lima",
+    "url": "git+https://github.com/limaformat/lima.git",
     "directory": "js"
   },
   "bugs": "https://github.com/limaformat/lima/issues",