@markup-carve/carve-lsp 0.1.0 → 0.1.2

package/dist/includes.test.js

@@ -0,0 +1,202 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { resolveIncludes } from './includes.js';
+// The graph-level half of PART 9 §19: recursion depth and total expanded byte
+// size. Expectations follow the cross-engine include-conformance vectors
+// `i03-*`, `i06-*` and `i11-*` in markup-carve/carve, which currently live only
+// on the unmerged spec branch for markup-carve/carve#291.
+/** In-memory resolver, matching the conformance suite's "virtual" mode. */
+function virtualResolver(files, reads) {
+    return (includePath) => {
+        reads?.push(includePath);
+        const source = files[includePath];
+        if (source === undefined)
+            return { ok: false, id: includePath, denial: 'not-found' };
+        return { ok: true, id: includePath, source, bytes: Buffer.byteLength(source, 'utf8') };
+    };
+}
+// ---------------------------------------------------------------------------
+// Opt-in: the pass is inert until a host hands over a resolver
+// ---------------------------------------------------------------------------
+test('with no resolver the directive stays literal, with no warning and no dependency (i03-no-resolver-literal)', () => {
+    const result = resolveIncludes('See {{ child.crv }} here.');
+    assert.deepEqual(result.warnings, []);
+    assert.deepEqual(result.dependencies, []);
+    assert.equal(result.bytes, 0);
+});
+test('with no resolver a resolvable-looking target is still not reported (i03-no-deps-without-resolver)', () => {
+    const reads = [];
+    const result = resolveIncludes('{{ child }}', { sourcePath: '/doc.crv' });
+    assert.deepEqual(result.dependencies, []);
+    assert.deepEqual(reads, []);
+});
+// ---------------------------------------------------------------------------
+// MUST 5: bound recursion depth
+// ---------------------------------------------------------------------------
+test('recursion stops at the depth limit and the unreached target is never read (i06-depth-limit)', () => {
+    const reads = [];
+    const result = resolveIncludes('{{ a }}', {
+        resolver: virtualResolver({ a: '{{ b }}', b: 'Deep.' }, reads),
+        maxDepth: 1,
+    });
+    assert.deepEqual(result.warnings.map((w) => ({ rule: w.rule, file: w.file })), [{ rule: 'include-depth', file: 'a' }]);
+    assert.deepEqual(result.dependencies, [
+        { id: 'a', resolved: true },
+        { id: 'b', resolved: false },
+    ]);
+    // The point of the bound: `b` is reported so a host can watch it, and is
+    // never handed to the resolver.
+    assert.deepEqual(reads, ['a']);
+});
+test('a deep chain is bounded rather than followed to its end', () => {
+    const files = {};
+    for (let i = 0; i < 40; i += 1)
+        files[`f${i}`] = `{{ f${i + 1} }}`;
+    files['f40'] = 'Bottom.';
+    const reads = [];
+    const result = resolveIncludes('{{ f0 }}', {
+        resolver: virtualResolver(files, reads),
+        maxDepth: 4,
+    });
+    assert.deepEqual(reads, ['f0', 'f1', 'f2', 'f3']);
+    assert.deepEqual(result.warnings.map((w) => w.rule), ['include-depth']);
+});
+// ---------------------------------------------------------------------------
+// MUST 6: bound total expanded byte size
+// ---------------------------------------------------------------------------
+test('the byte budget stops expansion with a warning (i06-budget-limit)', () => {
+    const result = resolveIncludes('{{ a }}', {
+        resolver: virtualResolver({ a: 'too large' }),
+        maxBytes: 1,
+    });
+    assert.deepEqual(result.warnings.map((w) => w.rule), ['include-budget']);
+    assert.deepEqual(result.dependencies, [{ id: 'a', resolved: true }]);
+});
+test('the budget is charged per occurrence, so repeated includes amplify against it', () => {
+    // The include-bomb shape: one small file pulled in many times. A budget
+    // charged per DISTINCT file would let this through unbounded.
+    const child = 'x'.repeat(100);
+    const source = '{{ a }}\n\n'.repeat(20);
+    const reads = [];
+    const result = resolveIncludes(source, {
+        resolver: virtualResolver({ a: child }, reads),
+        maxBytes: 250,
+    });
+    // Two occurrences fit inside 250 bytes. The third is read and then rejected
+    // by the charge that takes the total past the budget; the remaining
+    // seventeen are rejected before the resolver is called at all, so the
+    // exhausted budget stops the reads as well as the expansion.
+    assert.equal(reads.length, 3);
+    assert.equal(result.bytes, 300);
+    assert.equal(result.warnings.filter((w) => w.rule === 'include-budget').length, 18);
+});
+test('a transitive fan-out is stopped by the budget', () => {
+    // a includes b twice, b includes c twice, and so on: 2^n growth from a
+    // handful of small files, which is the amplification the MUST names.
+    const files = {
+        a: '{{ b }}\n\n{{ b }}',
+        b: '{{ c }}\n\n{{ c }}',
+        c: '{{ d }}\n\n{{ d }}',
+        d: 'x'.repeat(200),
+    };
+    const result = resolveIncludes('{{ a }}', {
+        resolver: virtualResolver(files),
+        maxBytes: 600,
+    });
+    assert.ok(result.warnings.some((w) => w.rule === 'include-budget'));
+});
+// ---------------------------------------------------------------------------
+// Cycles and dependency reporting
+// ---------------------------------------------------------------------------
+test('a two-file cycle is caught and attributed to the file that closed it (i06-cycle-two-file)', () => {
+    const result = resolveIncludes('{{ a }}', {
+        resolver: virtualResolver({ a: '{{ b }}', b: '{{ a }}' }),
+    });
+    assert.deepEqual(result.warnings.map((w) => ({ rule: w.rule, file: w.file })), [{ rule: 'include-cycle', file: 'b' }]);
+    assert.deepEqual(result.dependencies, [
+        { id: 'a', resolved: true },
+        { id: 'b', resolved: true },
+    ]);
+});
+test('a self-cycle is caught (i06-self-cycle)', () => {
+    const result = resolveIncludes('{{ a }}', { resolver: virtualResolver({ a: '{{ a }}' }) });
+    assert.deepEqual(result.warnings.map((w) => w.rule), ['include-cycle']);
+});
+test('cycle detection uses the recursion stack, so a diamond is not mistaken for a cycle', () => {
+    // a -> b -> d and a -> c -> d. `d` appears twice but never inside itself.
+    const result = resolveIncludes('{{ a }}', {
+        resolver: virtualResolver({ a: '{{ b }}\n\n{{ c }}', b: '{{ d }}', c: '{{ d }}', d: 'Leaf.' }),
+    });
+    assert.deepEqual(result.warnings, []);
+    assert.deepEqual(result.dependencies.map((d) => d.id), ['a', 'b', 'd', 'c']);
+});
+test('the same target twice is one dependency (i11-same-file-twice-once)', () => {
+    const result = resolveIncludes('{{ child }}\n\n{{ child }}', {
+        resolver: virtualResolver({ child: 'Body.' }),
+    });
+    assert.deepEqual(result.dependencies, [{ id: 'child', resolved: true }]);
+});
+test('a missing target is reported as an unresolved dependency (i11-missing-target-unresolved-dep)', () => {
+    const result = resolveIncludes('{{ present }}\n\n{{ absent }}', {
+        resolver: virtualResolver({ present: 'Here.' }),
+    });
+    assert.deepEqual(result.warnings.map((w) => w.rule), ['include-unresolved']);
+    assert.deepEqual(result.dependencies, [
+        { id: 'present', resolved: true },
+        { id: 'absent', resolved: false },
+    ]);
+});
+test('a resolver that throws yields a warning whose message carries no raw error text (i07-resolver-throws-no-leak)', () => {
+    const result = resolveIncludes('{{ a }}', {
+        resolver: () => {
+            throw new Error('ENOENT: open /home/someone/secret/a');
+        },
+    });
+    const [warning] = result.warnings;
+    assert.ok(warning);
+    assert.equal(warning.rule, 'include-unresolved');
+    assert.ok(!warning.message.includes('/home/someone'));
+    // The raw text is kept out of `message` but available for a log sink.
+    assert.ok(warning.detail?.includes('/home/someone'));
+});
+test('a warning carries the directive range and a 1-based line and column', () => {
+    const source = 'intro\n\n{{ absent }}\n';
+    const result = resolveIncludes(source, { resolver: virtualResolver({}) });
+    const [warning] = result.warnings;
+    assert.ok(warning);
+    assert.equal(warning.start, source.indexOf('{{ absent }}'));
+    assert.equal(warning.end, source.indexOf('{{ absent }}') + '{{ absent }}'.length);
+    assert.equal(warning.line, 3);
+    assert.equal(warning.column, 1);
+});
+test('a nested warning is anchored on the top-level directive of the open document', () => {
+    const source = 'intro\n\n{{ a }}\n';
+    const result = resolveIncludes(source, {
+        resolver: virtualResolver({ a: 'child text\n\n{{ absent }}' }),
+    });
+    const [warning] = result.warnings;
+    assert.ok(warning);
+    // The range must be valid in the document the client has open, and `file`
+    // says where the problem actually is.
+    assert.equal(warning.start, source.indexOf('{{ a }}'));
+    assert.equal(warning.file, 'a');
+});
+test('an unknown option warns and resolves nothing (i01-unknown-option-literal)', () => {
+    const reads = [];
+    const result = resolveIncludes('{{ child @nope:1 }}', {
+        resolver: virtualResolver({ child: 'text' }, reads),
+    });
+    assert.deepEqual(result.warnings.map((w) => w.rule), ['include-unknown-option']);
+    assert.deepEqual(result.dependencies, []);
+    assert.deepEqual(reads, []);
+});
+test('a directive inside a fence is not resolved even with a resolver active (i09-verbatim-fence-and-code-span)', () => {
+    const reads = [];
+    const result = resolveIncludes('```txt\n{{ child }}\n```\n\nUse `{{ child }}`.', {
+        resolver: virtualResolver({ child: 'expanded' }, reads),
+    });
+    assert.deepEqual(result.warnings, []);
+    assert.deepEqual(result.dependencies, []);
+    assert.deepEqual(reads, []);
+});
+//# sourceMappingURL=includes.test.js.map

package/dist/includes.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"includes.test.js","sourceRoot":"","sources":["../src/includes.test.ts"],"names":[],"mappings":"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"}

package/dist/inline-text.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Shared inline-to-text fallback for the three plain-text walks (outline
+ * symbols, cross-reference matching, go-to-definition).
+ *
+ * Carve represents a typographic substitution as a `smart_punctuation` inline
+ * node rather than writing the glyph into the text buffer (carve spec PART 9
+ * §8). The node carries the resolved `kind`, the author's source run in
+ * `value`, and - for quotes, whose glyph is locale-dependent and chosen during
+ * parsing - the resolved character in `glyph`.
+ *
+ * The walks here used if/else-if chains with no final branch, so a node type
+ * they did not know about contributed nothing. That failed silently: every
+ * quote, apostrophe, dash and ellipsis vanished from the extracted text, and
+ * `# Don't repeat yourself` became `Dont repeat yourself` in outline symbols
+ * and in the text a crossref resolves against.
+ *
+ * Preference order is `glyph`, then the source run. Resolving `kind` through
+ * carve's glyph table would be marginally more faithful for dashes and
+ * ellipses, but the table is not exported from the package root, and it does
+ * not matter for what these walks feed: heading ids normalize typographic
+ * output back to ASCII anyway, and the three walks stay consistent with each
+ * other either way, which is what reference matching actually needs.
+ */
+export declare function smartPunctuationText(node: unknown): string;

package/dist/inline-text.js

@@ -0,0 +1,34 @@
+/**
+ * Shared inline-to-text fallback for the three plain-text walks (outline
+ * symbols, cross-reference matching, go-to-definition).
+ *
+ * Carve represents a typographic substitution as a `smart_punctuation` inline
+ * node rather than writing the glyph into the text buffer (carve spec PART 9
+ * §8). The node carries the resolved `kind`, the author's source run in
+ * `value`, and - for quotes, whose glyph is locale-dependent and chosen during
+ * parsing - the resolved character in `glyph`.
+ *
+ * The walks here used if/else-if chains with no final branch, so a node type
+ * they did not know about contributed nothing. That failed silently: every
+ * quote, apostrophe, dash and ellipsis vanished from the extracted text, and
+ * `# Don't repeat yourself` became `Dont repeat yourself` in outline symbols
+ * and in the text a crossref resolves against.
+ *
+ * Preference order is `glyph`, then the source run. Resolving `kind` through
+ * carve's glyph table would be marginally more faithful for dashes and
+ * ellipses, but the table is not exported from the package root, and it does
+ * not matter for what these walks feed: heading ids normalize typographic
+ * output back to ASCII anyway, and the three walks stay consistent with each
+ * other either way, which is what reference matching actually needs.
+ */
+export function smartPunctuationText(node) {
+    if (typeof node !== 'object' || node === null)
+        return '';
+    const candidate = node;
+    if (candidate.type !== 'smart_punctuation')
+        return '';
+    if (typeof candidate.glyph === 'string')
+        return candidate.glyph;
+    return typeof candidate.value === 'string' ? candidate.value : '';
+}
+//# sourceMappingURL=inline-text.js.map

package/dist/inline-text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-text.js","sourceRoot":"","sources":["../src/inline-text.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,UAAU,oBAAoB,CAAC,IAAa;IAChD,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,IAAI;QAAE,OAAO,EAAE,CAAA;IACxD,MAAM,SAAS,GAAG,IAA4D,CAAA;IAC9E,IAAI,SAAS,CAAC,IAAI,KAAK,mBAAmB;QAAE,OAAO,EAAE,CAAA;IACrD,IAAI,OAAO,SAAS,CAAC,KAAK,KAAK,QAAQ;QAAE,OAAO,SAAS,CAAC,KAAK,CAAA;IAC/D,OAAO,OAAO,SAAS,CAAC,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAA;AACnE,CAAC"}

package/dist/inline-text.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/inline-text.test.js

@@ -0,0 +1,32 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { smartPunctuationText } from './inline-text.js';
+// The nodes below are written literally rather than produced by parse(), so the
+// tests hold whether or not the installed @markup-carve/carve emits
+// smart_punctuation yet. That is the point: the regression this guards against
+// arrives with a dependency bump, and a test that only exercises the current
+// dependency would pass right up until the day it mattered.
+test('a quote node contributes its resolved glyph', () => {
+    // Quote glyphs are locale-dependent and fixed during parsing, so the node
+    // carries the character rather than leaving it to a kind lookup.
+    assert.equal(smartPunctuationText({ type: 'smart_punctuation', kind: 'right_single_quote', value: "'", glyph: '’' }), '’');
+});
+test('a node without a glyph falls back to the author source run', () => {
+    assert.equal(smartPunctuationText({ type: 'smart_punctuation', kind: 'ellipsis', value: '...' }), '...');
+    assert.equal(smartPunctuationText({ type: 'smart_punctuation', kind: 'em_dash', value: '---' }), '---');
+});
+test('other node types contribute nothing', () => {
+    // The helper sits in a final else, so every unrecognized node reaches it. It
+    // must stay silent for anything that is not smart punctuation, matching the
+    // previous behavior of those chains.
+    assert.equal(smartPunctuationText({ type: 'soft_break' }), '');
+    assert.equal(smartPunctuationText({ type: 'text', value: 'x' }), '');
+});
+test('malformed input does not throw', () => {
+    assert.equal(smartPunctuationText(null), '');
+    assert.equal(smartPunctuationText(undefined), '');
+    assert.equal(smartPunctuationText('not a node'), '');
+    assert.equal(smartPunctuationText({ type: 'smart_punctuation' }), '');
+    assert.equal(smartPunctuationText({ type: 'smart_punctuation', value: 42 }), '');
+});
+//# sourceMappingURL=inline-text.test.js.map

package/dist/inline-text.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-text.test.js","sourceRoot":"","sources":["../src/inline-text.test.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,oBAAoB,CAAA;AACvC,OAAO,IAAI,MAAM,WAAW,CAAA;AAC5B,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAEvD,gFAAgF;AAChF,oEAAoE;AACpE,+EAA+E;AAC/E,6EAA6E;AAC7E,4DAA4D;AAE5D,IAAI,CAAC,6CAA6C,EAAE,GAAG,EAAE;IACvD,0EAA0E;IAC1E,iEAAiE;IACjE,MAAM,CAAC,KAAK,CACV,oBAAoB,CAAC,EAAE,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,oBAAoB,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,EACvG,GAAG,CACJ,CAAA;AACH,CAAC,CAAC,CAAA;AAEF,IAAI,CAAC,4DAA4D,EAAE,GAAG,EAAE;IACtE,MAAM,CAAC,KAAK,CACV,oBAAoB,CAAC,EAAE,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,EACnF,KAAK,CACN,CAAA;IACD,MAAM,CAAC,KAAK,CACV,oBAAoB,CAAC,EAAE,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,EAClF,KAAK,CACN,CAAA;AACH,CAAC,CAAC,CAAA;AAEF,IAAI,CAAC,qCAAqC,EAAE,GAAG,EAAE;IAC/C,6EAA6E;IAC7E,4EAA4E;IAC5E,qCAAqC;IACrC,MAAM,CAAC,KAAK,CAAC,oBAAoB,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC,EAAE,EAAE,CAAC,CAAA;IAC9D,MAAM,CAAC,KAAK,CAAC,oBAAoB,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,CAAA;AACtE,CAAC,CAAC,CAAA;AAEF,IAAI,CAAC,gCAAgC,EAAE,GAAG,EAAE;IAC1C,MAAM,CAAC,KAAK,CAAC,oBAAoB,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,CAAA;IAC5C,MAAM,CAAC,KAAK,CAAC,oBAAoB,CAAC,SAAS,CAAC,EAAE,EAAE,CAAC,CAAA;IACjD,MAAM,CAAC,KAAK,CAAC,oBAAoB,CAAC,YAAY,CAAC,EAAE,EAAE,CAAC,CAAA;IACpD,MAAM,CAAC,KAAK,CAAC,oBAAoB,CAAC,EAAE,IAAI,EAAE,mBAAmB,EAAE,CAAC,EAAE,EAAE,CAAC,CAAA;IACrE,MAAM,CAAC,KAAK,CAAC,oBAAoB,CAAC,EAAE,IAAI,EAAE,mBAAmB,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC,CAAA;AAClF,CAAC,CAAC,CAAA"}

package/dist/position-encoding.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/position-encoding.test.js

@@ -0,0 +1,143 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { hoverAt } from './hover.js';
+import { semanticTokens } from './semantic.js';
+import { astColumnToCharacter, characterToAstColumn, engineColumnUnit, setEngineColumnUnit, CODEPOINT_PROBE_END_COLUMN, COLUMN_PROBE, probeEndColumn, } from './position.js';
+function hoverText(hover) {
+    const contents = hover.contents;
+    return contents.value ?? String(hover.contents);
+}
+// Every assertion below is written against the SOURCE, not against the parser's
+// numbers: an LSP character is a UTF-16 index into the line, so `indexOf` is
+// the answer a client expects no matter which unit the installed parser counts
+// in. That is what makes these hold across the carve-js release that switched
+// columns from UTF-16 code units to codepoints (carve-js#447) - the release
+// this server's `^0.1.2` range picks up without a change here.
+const LINE = '\u{1F600} *bold* tail';
+const BOLD_START = LINE.indexOf('*');
+const BOLD_END = LINE.lastIndexOf('*') + 1;
+// The unit the PINNED engine reports, asserted directly.
+//
+// The test above is deliberately unit-agnostic, so a release that changes the
+// unit passes it - which is how the change got in last time. This one names the
+// answer, so the change arrives as a failing assertion instead of as correct
+// positions on ASCII and wrong ones on every emoji.
+//
+// That is exactly what happened: this assertion read `utf16` while the pin sat
+// at `0.1.2`, and raising the pin to `0.1.3` turned it red. `0.1.3` carries
+// carve-js#447, which counts codepoints and so conforms to spec PART 12
+// section 4. The expectation is flipped here rather than relaxed, because an
+// assertion that accepts either unit is the shape that let the change through
+// unnoticed the first time.
+//
+// The conversions in position.js have always had both branches; until this
+// release the `codepoint` one was unreachable with the installed engine. It is
+// the live branch now, and the unit-agnostic tests above cover it: they derive
+// every expectation from `indexOf` on the SOURCE, so they would fail if the
+// conversion returned the parser's raw codepoint column to an LSP client.
+test('the pinned engine counts codepoints', () => {
+    assert.equal(engineColumnUnit(), 'codepoint');
+});
+// This test used to retype the probe string and the constant, and then assert
+// that engineColumnUnit() agreed with a recomputation of its own expression:
+//
+//   const endColumn = parse('\u{1F600}x').children[0]?.pos?.endColumn
+//   assert.equal(engineColumnUnit(), endColumn === 3 ? 'codepoint' : 'utf16')
+//
+// Both sides read the same value through the same expression, so they agreed
+// for every value the engine can return - including `undefined`, where both
+// take the `utf16` branch and the "answer" is the catch-all rather than a
+// measurement. Two mutations, both measured against the old assertion, both
+// leaving the whole suite green at 134 of 134:
+//
+//   COLUMN_PROBE = 'abc'   a BMP-only probe has the same end column under
+//                          either unit, so the classifier can no longer tell
+//                          them apart. The test reparsed its own emoji probe
+//                          and never saw it.
+//   the classifier reads a property that does not exist, so every
+//                          classification is the fallback. The test reparsed
+//                          and got a real number, so it agreed with the
+//                          fallback and reported nothing.
+//
+// What follows checks three things separately, against values derived from the
+// probe rather than copied from it, and consumes the classifier's own reading
+// rather than making a second one.
+test('the probe can tell the two units apart', () => {
+    // A string is indexed in UTF-16 code units and iterated in codepoints, so a
+    // probe whose two lengths are equal reports the same end column under either
+    // unit and classifies nothing. This is a property of the probe alone, with no
+    // engine involved.
+    assert.notEqual(COLUMN_PROBE.length, [...COLUMN_PROBE].length, 'the probe has no astral character, so both units give it the same end column');
+    // And the constant the classifier compares against is that probe's codepoint
+    // end column - derived here, hard-coded there.
+    assert.equal(CODEPOINT_PROBE_END_COLUMN, [...COLUMN_PROBE].length + 1);
+});
+test('the installed parser answers the probe, rather than failing into the default', () => {
+    // engineColumnUnit() answers `utf16` when the parse throws or the position is
+    // absent. That is the right thing for a server not to crash on, and the wrong
+    // thing to accept silently in CI: a classification nobody measured reads
+    // exactly like one that was.
+    //
+    // probeEndColumn() rather than a reparse here: this is the reading the
+    // classifier actually makes, so a classifier that stops reading a position
+    // fails this. A reparse would agree with the fallback and report nothing.
+    const endColumn = probeEndColumn();
+    assert.equal(typeof endColumn, 'number', 'the installed engine placed no position on the probe, so the unit below is a default, not a reading');
+    // Only two answers are possible for this probe, one per unit. Anything else
+    // means the engine is not counting either of the units this server knows how
+    // to convert between.
+    assert.ok(endColumn === [...COLUMN_PROBE].length + 1 || endColumn === COLUMN_PROBE.length + 1, `the probe's end column is ${endColumn}, which is neither its codepoint length + 1 ` +
+        `(${[...COLUMN_PROBE].length + 1}) nor its UTF-16 length + 1 (${COLUMN_PROBE.length + 1})`);
+    assert.equal(engineColumnUnit(), endColumn === [...COLUMN_PROBE].length + 1 ? 'codepoint' : 'utf16');
+});
+test('an emoji before a construct does not shift its hover range', () => {
+    const hover = hoverAt(LINE, { line: 0, character: BOLD_START + 1 });
+    assert.ok(hover, 'expected a hover inside the bold span');
+    assert.match(hoverText(hover), /Bold/);
+    assert.deepEqual(hover.range, {
+        start: { line: 0, character: BOLD_START },
+        end: { line: 0, character: BOLD_END },
+    });
+});
+test('a cursor placed by UTF-16 character finds the node the client pointed at', () => {
+    // The character an editor sends counts UTF-16 units. Compared against a
+    // codepoint column without converting, this cursor lands one position early
+    // and hovers the surrounding text instead of the bold span.
+    const hover = hoverAt(LINE, { line: 0, character: BOLD_END - 2 });
+    assert.ok(hover);
+    assert.match(hoverText(hover), /Bold/);
+});
+test('semantic tokens land on the UTF-16 columns the client indexes by', () => {
+    const tokens = semanticTokens(LINE);
+    const bold = tokens.find((token) => token.character === BOLD_START);
+    assert.ok(bold, `expected a token at character ${BOLD_START}, got ${JSON.stringify(tokens)}`);
+    assert.equal(bold.length, BOLD_END - BOLD_START);
+});
+test('both parser readings map the same construct to the same LSP character', () => {
+    // The installed parser can only show one reading, and it is the one whose
+    // conversion is the identity - so the other branch is driven explicitly
+    // rather than left to run for the first time after a dependency bump.
+    // In `LINE` the opening `*` is codepoint column 3 and UTF-16 column 4,
+    // because the emoji is one codepoint and two code units.
+    try {
+        setEngineColumnUnit('codepoint');
+        assert.equal(astColumnToCharacter(LINE, 3), BOLD_START);
+        assert.equal(characterToAstColumn(LINE, BOLD_START), 3);
+        setEngineColumnUnit('utf16');
+        assert.equal(astColumnToCharacter(LINE, 4), BOLD_START);
+        assert.equal(characterToAstColumn(LINE, BOLD_START), 4);
+    }
+    finally {
+        setEngineColumnUnit(undefined);
+    }
+});
+test('a BMP-only document is unaffected either way', () => {
+    const line = 'a *bold* tail';
+    const hover = hoverAt(line, { line: 0, character: 3 });
+    assert.ok(hover);
+    assert.deepEqual(hover.range, {
+        start: { line: 0, character: line.indexOf('*') },
+        end: { line: 0, character: line.lastIndexOf('*') + 1 },
+    });
+});
+//# sourceMappingURL=position-encoding.test.js.map

package/dist/position-encoding.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"position-encoding.test.js","sourceRoot":"","sources":["../src/position-encoding.test.ts"],"names":[],"mappings":"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"}

package/dist/position.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Converts between the units Carve positions and LSP positions count.
+ *
+ * A Carve AST position counts UNICODE CODEPOINTS (spec PART 12 §4, chosen so
+ * an index always lands on a character boundary). An LSP position counts
+ * UTF-16 code units unless the client and server negotiate `positionEncoding`,
+ * which this server does not do, so UTF-16 is what every client here expects.
+ *
+ * The two units agree on the entire BMP and diverge on every astral character:
+ * one emoji earlier in the line shifts every LSP column after it by one. So a
+ * position read off the AST cannot be handed to a client, nor a position from
+ * a client compared against the AST, without passing through here.
+ */
+/**
+ * A 1-based codepoint column, as an AST position reports it, to the 0-based
+ * UTF-16 character an LSP range carries.
+ */
+export declare function codepointColumnToUtf16(lineText: string, column: number): number;
+/**
+ * The 0-based UTF-16 character an LSP request carries, to the 1-based codepoint
+ * column an AST position can be compared against.
+ *
+ * A character index pointing into the middle of a surrogate pair resolves to
+ * the column after that pair. There is no column for half a character, and a
+ * client only produces one by placing a cursor inside one.
+ */
+export declare function utf16CharToCodepointColumn(lineText: string, character: number): number;
+/**
+ * The document's lines, line endings normalized, indexed 0-based - the form
+ * both conversions above need to see a line's characters.
+ */
+export declare function sourceLines(source: string): string[];
+/**
+ * Which unit the installed parser's columns are in.
+ *
+ * This is not a constant, because the dependency range spans both answers.
+ * Positions arrived in @markup-carve/carve counting UTF-16 code units, which
+ * is what a JavaScript string is indexed by; carve-js#447 then made them count
+ * codepoints, to conform to the spec. Both satisfy `^0.1.2`, so a build of this
+ * server installed today and the same build installed after that release are
+ * handed different numbers for the same document, and nothing in the package
+ * metadata distinguishes them.
+ *
+ * Rather than guess, ask: one astral character is two UTF-16 code units and one
+ * codepoint, so a two-character probe reports a different end column under each
+ * unit. The answer is cached - it cannot change within a process.
+ */
+export declare const COLUMN_PROBE = "\uD83D\uDE00x";
+export declare const CODEPOINT_PROBE_END_COLUMN = 3;
+/**
+ * The raw reading the classification is made from: the probe's end column as
+ * the installed parser reports it, or `undefined` when the parser cannot answer
+ * at all.
+ *
+ * Split out and exported so the guard test can consume THE READING the
+ * classifier uses, instead of computing its own copy of it. A test that reparses
+ * the probe itself agrees with `engineColumnUnit` for every value including
+ * `undefined`, so it cannot see the difference between a measurement and the
+ * fallback below - which is the only thing worth checking here.
+ */
+export declare function probeEndColumn(): number | undefined;
+export declare function engineColumnUnit(): 'codepoint' | 'utf16';
+/**
+ * Test seam: pin the unit, or pass `undefined` to probe again.
+ *
+ * The installed parser can only demonstrate one of the two readings, and it is
+ * the one whose conversion is the identity - so without this the codepoint
+ * branch would ship untested and unrun until a dependency bump made it live.
+ */
+export declare function setEngineColumnUnit(unit: 'codepoint' | 'utf16' | undefined): void;
+/**
+ * A 1-based column as the installed parser reports it, to the 0-based UTF-16
+ * character an LSP range carries. Use this rather than the raw conversion:
+ * under a UTF-16 parser the columns already are LSP characters, and converting
+ * them would introduce the very shift it is meant to remove.
+ */
+export declare function astColumnToCharacter(lineText: string, column: number): number;
+/**
+ * The 0-based UTF-16 character an LSP request carries, to the 1-based column
+ * the installed parser's positions can be compared against.
+ */
+export declare function characterToAstColumn(lineText: string, character: number): number;