@limaformat/lima 0.5.1 → 0.7.0

package/CHANGELOG.md

@@ -4,14 +4,109 @@ 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.2](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.1](https://github.com/limaformat/lima/blob/main/docs/lima-references-2.0-spec.md)
+carry their own.
 
 ## [Unreleased]
 
+## [0.7.0] — 2026-10-30
+
+Lima Core 1.2 and References 2.1: an unquoted key may be written in any
+script. It starts with a letter or number of Unicode 18.0 or `_`, and after
+its first character also holds marks, `*` and `·`, so keys can be written
+in any language and gendered (`größe`, `題名`, `autor*in`, `autor·in`);
+references reach every such key. Core 1.2 also states in one table what
+each kind of line does where it stands (§7.1), without changing an outcome.
+
+### Added
+
+- Unquoted keys and reference names take Unicode letters, marks and numbers
+  (Unicode 18.0, fixed by the specification) and `*` and `·` after their
+  first character. The categories come from a generated table, not the
+  host's Unicode support, and no dependency; ASCII keys are read as fast as
+  before.
+- Hints: whitespace other than spaces before a key, a FULLWIDTH COLON
+  (U+FF1A) in place of `: `, and the key-grammar hint for a key such as
+  `x y: 2` at every level.
+
+### Changed
+
+- A line whose key Core 1.1 rejected for its characters, and Core 1.2
+  admits, is an entry now; non-strict mode skipped it, strict mode threw.
+- A document with a lone surrogate is rejected with `INVALID_DOCUMENT` and
+  the line it is on (Core §1), in both modes.
+- Node.js 22 or later (`String.prototype.isWellFormed`).
+
+## [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

package/README.md

@@ -38,10 +38,10 @@ tags:
 Three functions are exported:
 
 - `parseCore(input, options?)` — the base format only.
-- `parse(input, options?)` — the primary References 2.0 parser; adds
+- `parse(input, options?)` — the primary References <!-- facts:language.references_version -->2.1<!-- /facts --> parser; adds
   `${key}` document references and `$(key)` external partials.
 - `parseReferences(input, options?)` — deprecated compatibility alias for
-  `parse` with the same References 2.0 semantics.
+  `parse` with the same References <!-- facts:language.references_version -->2.1<!-- /facts --> semantics.
 
 ```ts
 parse(frontmatter, { strict: true })
@@ -50,15 +50,15 @@ parse(frontmatter, { mode: 'core' }) // same reference-unaware path as parseCore
 ```
 
 The **[guide](https://github.com/limaformat/lima/blob/main/docs/guide.md)**
-covers Core and References 2.0 syntax, resource limits, strict mode, and the
+covers Core <!-- facts:language.core_version -->1.2<!-- /facts --> and References <!-- facts:language.references_version -->2.1<!-- /facts --> syntax, resource limits, strict mode, and the
 public API. The normative rules are defined in the
-**[References 2.0 specification](https://github.com/limaformat/lima/blob/main/docs/lima-references-2.0-spec.md)**.
+**[References <!-- facts:language.references_version -->2.1<!-- /facts --> specification](https://github.com/limaformat/lima/blob/main/docs/lima-references-2.0-spec.md)**.
 
 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)
-and [Lima References 2.0](https://github.com/limaformat/lima/blob/main/docs/lima-references-2.0-spec.md)
+The [Lima Core <!-- facts:language.core_version -->1.2<!-- /facts -->](https://github.com/limaformat/lima/blob/main/docs/lima-core-1.0-spec.md)
+and [Lima References <!-- facts:language.references_version -->2.1<!-- /facts -->](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
 independent conformance suite.

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

@@ -10,7 +10,8 @@
  */
 import { checkKeyLength, checkDuplicateKey, NESTING_DEPTH_LIMIT } from './normalize.js';
 import { stripKeyQuotes, stripComment, stripCommentKeepEscapes, parseQuotedOrTyped, closingQuoteIndex, isValidKey, } from './scalars.js';
-import { parseFlowMapping, parseFlowOrScalarValue } from './flow.js';
+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 { isTrimWhitespace } from './chars.js';
@@ -48,9 +49,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) => {
+/** 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 (raw !== '|') {
+    if (!marker) {
         const value = parseFlowOrScalarValue(raw, ctx, keyLine, builder, inlineSource(wantSource, ctx, keyLine, valueCol, rawUndecoded));
         cursor.next();
         return value;
@@ -58,7 +60,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 +87,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 +128,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 +164,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}"${specificKeyHint(trimmed) ?? KEY_GRAMMAR_HINT}`,
+});
 /** Shared block grammar consuming one mutable physical-line cursor. */
-const parseCursorBlock = (cursor, baseIndent, ctx, baseLine, builder) => {
+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 +189,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 +223,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 +248,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 +265,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 +277,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 +330,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 +357,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 +374,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 +397,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 +418,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 +429,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 +453,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/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
@@ -34,7 +34,7 @@ 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
@@ -75,10 +75,11 @@ 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
  * guaranteed to always pass through unresolved, even in strict mode.
  */
+export declare const parseCoreValidated: <T extends Record<string, unknown> = Meta>(frontMatter: string, options?: CoreOptions) => T;
 export declare const parseCore: <T extends Record<string, unknown> = Meta>(frontMatter: string, options?: CoreOptions) => T;