carrick 0.3.116 → 0.3.118

package/sidecar/dist/src/library-claims.js

@@ -49,6 +49,8 @@ const HTTP_METHODS = new Set([
     'HEAD',
     'OPTIONS',
 ]);
+/** The methods a route may register: every request method, and `ALL` for a member that registers each. */
+const ROUTE_METHODS = new Set([...HTTP_METHODS, 'ALL']);
 /**
  * Interfaces whose members every value of that kind inherits. A key found only
  * on one of these (`constructor`, `toString`, a string's `length`) is not a
@@ -100,6 +102,18 @@ const MESSAGE_RULES = {
     message: true,
     ops: new Set(['send', 'receive', 'request']),
 };
+/**
+ * An `http_client` export whose claims in the request use a label v2 field
+ * (`hasV2Field`) is read as the store's other roles are: its makers, `of`
+ * and `on`, paths and the name-slot rules, plus the method fields. An export
+ * whose claims use none keeps the #1564 checks exactly (`HTTP_RULES`).
+ */
+const HTTP_V2_RULES = { http: false, message: true, ops: new Set(['request']), methods: HTTP_METHODS };
+/**
+ * A server framework's route members: a `receive` op whose name is the path,
+ * the method from the member's own name (`get` registers GET) or from a slot.
+ */
+const SERVER_RULES = { http: false, message: true, ops: new Set(['receive']), methods: ROUTE_METHODS };
 /**
  * The role table: the role alone picks the checks. A role this build does
  * not read yet (GraphQL executors, server mounts) answers `role_unsupported`,
@@ -111,9 +125,21 @@ const ROLE_TABLE = {
     in_process_bus: MESSAGE_RULES,
     socket: MESSAGE_RULES,
     graphql_client: undefined,
-    server_framework: undefined,
+    server_framework: SERVER_RULES,
     none: undefined,
 };
+/**
+ * Whether a claim uses a field label structure v2 added (carrick#2434). An
+ * `http_client` export with one such claim in the request is read under
+ * `HTTP_V2_RULES`.
+ */
+function hasV2Field(claim) {
+    if (claim.kind === 'make')
+        return claim.runs !== undefined;
+    if (claim.kind !== 'op')
+        return false;
+    return claim.method_default !== undefined || claim.base !== undefined || claim.runs !== undefined || claim.yields !== undefined;
+}
 const VERIFIED = { verdict: 'verified' };
 const failed = (reason) => ({ verdict: 'failed', reason });
 const unchecked = (reason) => ({ verdict: 'unchecked', reason });
@@ -230,6 +256,13 @@ export class LibraryClaimsVerifier {
         const factoryKeys = new Map();
         // The roles each (package, export) is given across the request.
         const roles = new Map();
+        // The `http_client` exports read under the label v2 rules.
+        const v2Exports = new Set();
+        for (const check of checks) {
+            if (check.role === 'http_client' && hasV2Field(check.claim))
+                v2Exports.add(exportKey(check));
+        }
+        const rulesFor = (check) => check.role === 'http_client' && v2Exports.has(exportKey(check)) ? HTTP_V2_RULES : ROLE_TABLE[check.role];
         for (const check of checks) {
             const key = exportKey(check);
             if (!importIndex.has(key)) {
@@ -260,7 +293,7 @@ export class LibraryClaimsVerifier {
         const builtLines = [];
         const builtIndex = new Map();
         for (const check of checks) {
-            if (!ROLE_TABLE[check.role]?.message)
+            if (!rulesFor(check)?.message)
                 continue;
             const built = builtReceiver(check);
             if (built === undefined)
@@ -326,6 +359,7 @@ export class LibraryClaimsVerifier {
                 const receiverPath = parseReceiver(check.receiver);
                 let types = [exported.type];
                 let makerBindsName = false;
+                let makerHolding;
                 if (receiverPath.maker) {
                     const maker = receiverPath.maker;
                     const makers = checks
@@ -336,10 +370,12 @@ export class LibraryClaimsVerifier {
                         other.claim.kind === 'make' &&
                         other.claim.form === maker.form &&
                         other.claim.member === maker.member);
-                    const made = holdingReturns(makers.map(({ i }) => judge(i)), atDefaults(check, receiverPath.base));
+                    const makerJudgements = makers.map(({ i }) => judge(i));
+                    const made = holdingReturns(makerJudgements, atDefaults(check, receiverPath.base));
                     if ('reason' in made)
                         return { reason: made.reason === 'unresolved' ? 'maker_unresolved' : 'maker_unverified' };
                     types = made.value;
+                    makerHolding = makerJudgements.reduce((common, judgement) => common.filter(sig => judgement.holding.includes(sig)), makerJudgements[0].holding);
                     makerBindsName = makers.some(({ other }) => other.claim.kind === 'make' && other.claim.name !== undefined);
                 }
                 if (receiverPath.scope !== undefined) {
@@ -366,6 +402,7 @@ export class LibraryClaimsVerifier {
                         home: reader.homeOf(check.package, [exported.target, ...typeSymbols(type)]),
                         makerBindsName,
                         scoped: receiverPath.scope !== undefined,
+                        makerHolding,
                     })),
                 };
             };
@@ -401,7 +438,7 @@ export class LibraryClaimsVerifier {
             };
             const judgeCheck = (index) => {
                 const check = checks[index];
-                const rules = ROLE_TABLE[check.role];
+                const rules = rulesFor(check);
                 if (!rules)
                     return { outcome: unchecked('role_unsupported') };
                 // An export given two roles is classified two ways; neither is a fact.
@@ -446,7 +483,7 @@ export class LibraryClaimsVerifier {
                 const builtAtDefaults = built === undefined ? undefined : atDefaults(check, built);
                 const holding = [];
                 for (const receiver of receivers.value) {
-                    const result = reader.judgeMessage(receiver, check.claim, builtAtDefaults);
+                    const result = reader.judgeMessage(receiver, check.claim, rules, builtAtDefaults);
                     if (result.outcome.verdict !== 'verified')
                         return result;
                     holding.push(...(result.holding ?? []));
@@ -1285,14 +1322,14 @@ class DeclarationReader {
      * overloads it holds on. `built` is the probe's no-argument build of the
      * receiver a maker or scope claim makes (see `returnOf`).
      */
-    judgeMessage(receiver, claim, built) {
+    judgeMessage(receiver, claim, rules, built) {
         switch (claim.kind) {
             case 'make':
                 return this.judgeMake(receiver, claim, built);
             case 'scope':
                 return this.judgeScope(receiver, claim, built);
             case 'op':
-                return { outcome: this.judgeOp(receiver, claim) };
+                return { outcome: this.judgeOp(receiver, claim, rules) };
             case 'reserved':
                 return { outcome: this.judgeReserved(receiver, claim) };
         }
@@ -1308,7 +1345,13 @@ class DeclarationReader {
      * `handler` slot; a queue (`new Queue("emails")`) one with a positional name.
      */
     judgeMake(receiver, claim, built) {
-        const layout = this.layout({ base: claim.base, prefix: claim.prefix, name: claim.name, handler: claim.handler });
+        const layout = this.layout({
+            base: claim.base,
+            prefix: claim.prefix,
+            name: claim.name,
+            handler: claim.handler,
+            runs: claim.runs,
+        });
         if ('failure' in layout)
             return { outcome: layout.failure };
         const callee = this.ownCallee(receiver, [], claim.member, claim.form);
@@ -1368,23 +1411,48 @@ class DeclarationReader {
      * instance's maker claim has a `name` slot, or the receiver came through a
      * scope.
      */
-    judgeOp(receiver, claim) {
-        if (claim.method !== undefined || claim.method_key !== undefined || claim.options !== undefined) {
+    judgeOp(receiver, claim, rules) {
+        const method = this.methodOutcome(claim, rules);
+        if (method)
+            return method;
+        // What a handler is handed is read on a receive op's handler only.
+        if (claim.yields !== undefined && (claim.op !== 'receive' || claim.handler === undefined)) {
             return unchecked('claim_invalid');
         }
         const name = claim.name;
-        // A send carries a payload: a name alone on `send(data)` is the data.
-        if (name === undefined || (claim.op === 'send' && claim.payload === undefined))
+        // A send carries a payload: a name alone on `send(data)` is the data. An
+        // op that runs a function or client it is handed takes its name from
+        // what it runs, and one that hands its handler a receiver (a server's
+        // connection event) names nothing on the wire itself, so neither needs a
+        // name of its own.
+        const nameless = claim.runs !== undefined || claim.yields !== undefined;
+        if ((name === undefined && !nameless) || (claim.op === 'send' && claim.payload === undefined)) {
             return unchecked('claim_invalid');
+        }
         let nameSlot;
-        if ('bound' in name) {
+        if (name === undefined) {
+            nameSlot = undefined;
+        }
+        else if ('bound' in name) {
             if (name.bound === 'maker' ? !receiver.makerBindsName : !receiver.scoped)
                 return failed('name_unbound');
         }
         else {
             nameSlot = name;
         }
-        const layout = this.layout({ name: nameSlot, payload: claim.payload, handler: claim.handler, ack: claim.ack });
+        const runs = claim.runs;
+        const boundRuns = runs?.bound === 'maker' ? runs : undefined;
+        if (boundRuns && !receiver.makerHolding)
+            return failed('runs_unbound');
+        const layout = this.layout({
+            name: nameSlot,
+            payload: claim.payload,
+            handler: claim.handler,
+            ack: claim.ack,
+            base: claim.base,
+            method: claim.method_key,
+            runs: runs && !boundRuns ? { arg: runs.arg, ...(runs.key === undefined ? {} : { key: runs.key }) } : undefined,
+        });
         if ('failure' in layout)
             return layout.failure;
         const callee = this.ownCallee(receiver, claim.path ?? [], claim.member, 'call');
@@ -1392,13 +1460,131 @@ class DeclarationReader {
             return callee.failure;
         const labels = claim.key_labels ?? {};
         let best;
+        let held = false;
         for (const signature of callee.signatures) {
-            const result = this.messageSignatureOutcome(signature, layout.value, labels);
-            if (result.rank === Infinity)
-                return VERIFIED;
+            let result = this.messageSignatureOutcome(signature, layout.value, labels);
+            if (result.rank === Infinity && claim.yields !== undefined) {
+                const given = this.yieldsOutcome(signature, claim.handler, claim.yields, receiver);
+                if (given)
+                    result = { rank: 5, outcome: given };
+            }
+            if (result.rank === Infinity) {
+                held = true;
+                break;
+            }
             best = furthest(best, result.rank, result.outcome);
         }
-        return best.outcome;
+        if (!held)
+            return best.outcome;
+        if (boundRuns)
+            return this.boundRunsOutcome(receiver.makerHolding, boundRuns);
+        return VERIFIED;
+    }
+    /**
+     * The method fields of an op (label structure v2, carrick#2434), under the
+     * role's method words. Without method words (the message roles), an op
+     * carrying `method`, `method_key`, `options`, `method_default` or `base` is
+     * `claim_invalid`, as before. With them:
+     * - `method` is the member's own name, upper-cased (ASCII only), and a
+     *   method word: `get` registers or sends GET (`method_not_member_verb`);
+     * - `method_key` is where the method sits, a slot that accepts a string or
+     *   a method literal (read with the call's other parts);
+     * - `method_default` is a method word (`method_not_word`): beside
+     *   `method_key`, the method when that option is absent; alone, the one
+     *   method the call sends. Beside `method`, it says nothing new and is
+     *   `claim_invalid`, as is `method` beside `method_key`;
+     * - `options` belongs to the #1564 checks and is `claim_invalid`.
+     * Undefined when the fields hold so far; their slots are read with the
+     * call's other parts.
+     */
+    methodOutcome(claim, rules) {
+        const words = rules.methods;
+        if (!words) {
+            const any = claim.method !== undefined ||
+                claim.method_key !== undefined ||
+                claim.options !== undefined ||
+                claim.method_default !== undefined ||
+                claim.base !== undefined;
+            return any ? unchecked('claim_invalid') : undefined;
+        }
+        if (claim.options !== undefined)
+            return unchecked('claim_invalid');
+        if (claim.method !== undefined && (claim.method_key !== undefined || claim.method_default !== undefined)) {
+            return unchecked('claim_invalid');
+        }
+        if (claim.method !== undefined) {
+            if (claim.member === null || claim.method !== asciiUpperCase(claim.member) || !words.has(claim.method)) {
+                return failed('method_not_member_verb');
+            }
+        }
+        if (claim.method_default !== undefined && !words.has(claim.method_default))
+            return failed('method_not_word');
+        return undefined;
+    }
+    /**
+     * `runs: { bound: 'maker', arg, key }`: some overload the instance's maker
+     * holds on takes a function with a declared signature there (the function
+     * a mutation object's `mutate` runs is the one its maker was given).
+     */
+    boundRunsOutcome(holding, runs) {
+        let best;
+        for (const signature of holding) {
+            let declared = this.keyParameterAt(signature, runs.arg);
+            if (declared !== undefined && runs.key !== undefined) {
+                const property = this.declaredProperty(declared, runs.key);
+                if (!property) {
+                    best = furthest(best, 2, failed('key_missing'));
+                    continue;
+                }
+                declared = this.checker.getTypeOfSymbol(property);
+            }
+            const failure = this.runsFailure(declared);
+            if (!failure)
+                return VERIFIED;
+            best = furthest(best, 3, failure);
+        }
+        return best?.outcome ?? failed('param_missing');
+    }
+    /** A `runs` slot: a function with a declared signature, as a handler is, under its own reasons. */
+    runsFailure(declared) {
+        const failure = this.handlerFailure(declared);
+        if (!failure || failure.verdict === 'verified')
+            return failure;
+        const reason = failure.reason.replace(/^handler_/, 'runs_');
+        return failure.verdict === 'failed' ? failed(reason) : unchecked(reason);
+    }
+    /**
+     * `yields: { param, export, side }` on a receive op: some signature of the
+     * handler this overload takes declares a parameter at `param` whose type
+     * is the package's own export named `export` (a class, or the interface
+     * an instance has), declared in the receiver's home packages. `side` is
+     * `client` or `server` (`yields_side_invalid`). Undefined when it holds.
+     */
+    yieldsOutcome(signature, handler, yields, receiver) {
+        if (yields.side !== 'client' && yields.side !== 'server')
+            return failed('yields_side_invalid');
+        let declared = this.keyParameterAt(signature, handler.arg);
+        if (declared !== undefined && handler.key !== undefined) {
+            const property = this.declaredProperty(declared, handler.key);
+            declared = property ? this.checker.getTypeOfSymbol(property) : undefined;
+        }
+        if (declared === undefined)
+            return failed('param_missing');
+        const slot = this.throughConditional(this.throughConstraint(declared));
+        if (slot === VARIADIC)
+            return unchecked('handler_untyped');
+        for (const part of this.parts(slot)) {
+            for (const handed of part.getCallSignatures()) {
+                const given = this.parameterAt(handed, yields.param);
+                if (given === undefined || given === VARIADIC)
+                    continue;
+                const named = typeSymbols(given).some(symbol => symbol?.getName() === yields.export &&
+                    (symbol.declarations ?? []).some(declaration => this.isOwnFile(declaration.getSourceFile(), receiver.home)));
+                if (named)
+                    return undefined;
+            }
+        }
+        return failed('yields_not_export');
     }
     /**
      * The declarations spell `name` in one of `member`'s parameters: an
@@ -1462,6 +1648,14 @@ class DeclarationReader {
      */
     messageSignatureOutcome(signature, layout, labels) {
         for (const [arg, part] of layout.positional) {
+            if (part === 'method') {
+                const declared = this.keyParameterAt(signature, arg);
+                if (declared === undefined)
+                    return { rank: 1, outcome: failed('param_missing') };
+                if (!this.acceptsMethod(declared))
+                    return { rank: 1, outcome: this.slotFailure(declared, 'method_not_string') };
+                continue;
+            }
             if (part !== 'name' && part !== 'base' && part !== 'prefix')
                 continue;
             const declared = this.keyParameterAt(signature, arg);
@@ -1486,9 +1680,10 @@ class DeclarationReader {
             }
         }
         for (const [arg, part] of layout.positional) {
-            if (part !== 'handler' && part !== 'ack')
+            if (part !== 'handler' && part !== 'ack' && part !== 'runs')
                 continue;
-            const failure = this.handlerFailure(this.keyParameterAt(signature, arg));
+            const declared = this.keyParameterAt(signature, arg);
+            const failure = part === 'runs' ? this.runsFailure(declared) : this.handlerFailure(declared);
             if (failure)
                 return { rank: 3, outcome: failure };
         }
@@ -1537,6 +1732,17 @@ class DeclarationReader {
                     failure = { rank: 3, outcome: failed('payload_is_function') };
                     break;
                 }
+                if (part === 'method' && !this.acceptsMethod(type)) {
+                    failure = { rank: 3, outcome: this.slotFailure(type, 'method_not_string') };
+                    break;
+                }
+                if (part === 'runs') {
+                    const bad = this.runsFailure(type);
+                    if (bad) {
+                        failure = { rank: 3, outcome: bad };
+                        break;
+                    }
+                }
                 if (part === 'handler' || part === 'ack') {
                     const bad = this.handlerFailure(type);
                     if (bad) {
@@ -2690,16 +2896,21 @@ class DeclarationReader {
     }
     /**
      * What a factory builds says nothing: the type itself, or any branch of a
-     * conditional return type, does.
+     * conditional return type, does. A conditional whose branches lead back to
+     * itself (a recursive alias) is read once: `seen` holds the conditionals
+     * on the way down, and one met again says nothing new.
      */
-    returnSaysNothing(type) {
+    returnSaysNothing(type, seen = new Set()) {
         if (this.saysNothing(type))
             return true;
         return this.parts(type).some(part => {
             if (!(part.flags & ts.TypeFlags.Conditional))
                 return false;
             const node = part.root.node;
-            return [node.trueType, node.falseType].some(branch => this.returnSaysNothing(this.checker.getTypeFromTypeNode(branch)));
+            if (seen.has(node))
+                return false;
+            seen.add(node);
+            return [node.trueType, node.falseType].some(branch => this.returnSaysNothing(this.checker.getTypeFromTypeNode(branch), seen));
         });
     }
     /** `any` (an unresolved type included) or `unknown`. */

package/sidecar/dist/src/module-format.d.ts

@@ -29,4 +29,22 @@
  * and is left unresolved rather than given another import's mode.
  */
 import { type ResolutionHostFactory } from 'ts-morph';
-export declare const moduleFormatResolutionHost: ResolutionHostFactory;
+/**
+ * The editor's project-reference rule for the program's owner config
+ * (`ReferenceRedirect` in `capture/reference-redirect.ts`, carrick#2418),
+ * restated here because this module is outside the capture seam.
+ */
+export interface ResolutionRedirect {
+    referenceFor(containingFile: string): unknown;
+    resolutionHost<H extends {
+        fileExists(fileName: string): boolean;
+    }>(host: H): H;
+    sourceAnswer<R extends {
+        resolvedFileName: string;
+    } | undefined>(answer: R): R;
+}
+/**
+ * The resolution host factory, resolving through `redirect` when the owner
+ * config references other projects.
+ */
+export declare const moduleFormatResolutionHost: (redirect?: ResolutionRedirect) => ResolutionHostFactory;

package/sidecar/dist/src/module-format.js

@@ -55,7 +55,12 @@ function usagesOf(file) {
 }
 /** Why a module name cannot be given one mode: see the header. */
 const UNPLACED = Symbol('unplaced');
-export const moduleFormatResolutionHost = (host, getOptions) => {
+/**
+ * The resolution host factory, resolving through `redirect` when the owner
+ * config references other projects.
+ */
+export const moduleFormatResolutionHost = (redirect) => (host, getOptions) => {
+    const resolutionHost = redirect ? redirect.resolutionHost(host) : host;
     let cache;
     let cacheOptions;
     const cacheFor = (options) => {
@@ -95,7 +100,9 @@ export const moduleFormatResolutionHost = (host, getOptions) => {
                 const mode = modeOf(name);
                 if (mode === UNPLACED)
                     return undefined;
-                return ts.resolveModuleName(name, containingFile, compilerOptions, host, resolutionCache, redirectedReference, mode).resolvedModule;
+                const answer = ts.resolveModuleName(name, containingFile, compilerOptions, resolutionHost, resolutionCache, redirectedReference ??
+                    redirect?.referenceFor(containingFile), mode).resolvedModule;
+                return redirect ? redirect.sourceAnswer(answer) : answer;
             });
         },
     };

package/sidecar/dist/src/position-rows.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Per-position compiler rows for a service (carrick#2405, move 2 of the fact
+ * layer). Record-only: nothing in a scan reads the file yet.
+ *
+ * For every source file the scanner sends, one row for each position of six
+ * kinds, each holding what the compiler knows there: the symbol, the
+ * declaration it is attributed to (file and line), the package that declares
+ * it and the type text.
+ *
+ * | kind      | node                                              | symbol of                 | type of        |
+ * |-----------|---------------------------------------------------|---------------------------|----------------|
+ * | `call`    | call, `new`, tagged template                      | the callee's name         | the call       |
+ * | `member`  | property or element access                        | the name or the argument  | the access     |
+ * | `compare` | `=== !== == != < > <= >= instanceof in`           | the left operand          | the left operand |
+ * | `ident`   | an identifier in expression position              | itself                    | itself         |
+ * | `impl`    | a `call` or `member` whose declaration has no body | an implementation of it  | nothing        |
+ * | `jsx`     | a JSX opening or self-closing element's tag        | the tag's name           | the tag        |
+ *
+ * An `impl` row (version 2, carrick#2430) follows the `call` or `member` row
+ * it belongs to and has its span: one per declaration that go-to-implementation
+ * names for that row's declaration, when that declaration is an interface's
+ * or type literal's method, a function-typed property signature, an abstract
+ * member, or a function-typed class property or parameter with no
+ * initializer. Its `decl_*` name the implementing declaration. Past
+ * {@link IMPL_CAP} the row is one, with {@link FLAG_TOO_MANY} and nothing else.
+ *
+ * A row's key is `(start, end, kind)`, except that several `impl` rows share
+ * one: TypeScript `getStart()`/`getEnd()` of the node, in UTF-16 code units
+ * from the start of the file, which is what the scanner's `sidecar_position`
+ * gives for an SWC span. Every path written is relative to the scanned repo's
+ * root, with `/` separators.
+ *
+ * Each file is read in the program of the project that owns it
+ * (`ProjectLoader.projectKeyFor`, carrick#1604), one owner's program at a
+ * time: a group's program is released before the next one is built. A file
+ * the owner's program does not take (JavaScript under a config without
+ * `allowJs`) is read after every owner, in that owner's `scripts` program
+ * (`ProjectLoader.scriptProjectFor`, carrick#2413), with the owner's root
+ * declaration files beside it so that the globals they declare are declared.
+ *
+ * The file format is pinned on the scanner side by `src/position_rows.rs`.
+ */
+import { ts } from 'ts-morph';
+import type { ProjectLoader } from './project-loader.js';
+import type { PositionRowsCounts } from './types.js';
+/** The format's version, written in the header. */
+export declare const POSITION_ROWS_VERSION = 2;
+/** The type is `any`, declared or inferred. Never set with the error type. */
+export declare const FLAG_ANY = 1;
+/** The type is the compiler's error type: something did not resolve. */
+export declare const FLAG_ERROR_TYPE = 2;
+/** The checker threw at this node; the row holds nothing else. */
+export declare const FLAG_CHECKER_THREW = 4;
+/** The declaration is outside the checkout, not the default library and in no installed package. */
+export declare const FLAG_DECLARATION_UNNAMED = 8;
+/** An `impl` row standing for more implementations than {@link IMPL_CAP}; it names none. */
+export declare const FLAG_TOO_MANY = 16;
+/** The most implementations one declaration's `impl` rows list. */
+export declare const IMPL_CAP = 16;
+/** The kinds {@link kindOf} gives a node; `impl` and `jsx` rows are written beside them. */
+export type NodeKind = 'call' | 'member' | 'compare' | 'ident';
+export type PositionKind = NodeKind | 'impl' | 'jsx';
+/** `[kind, start, end, symbol, decl_file, decl_line, decl_package, type_text, flags]` */
+export type PositionRow = [
+    PositionKind,
+    number,
+    number,
+    string | null,
+    string | null,
+    number | null,
+    string | null,
+    string | null,
+    number
+];
+export interface PositionRowsOptions {
+    loader: ProjectLoader;
+    /** Absolute paths, written in this order. */
+    files: string[];
+    scanRoot: string;
+    outPath: string;
+    service: string;
+    /** Called after each file is walked or skipped. */
+    onFile?: () => void;
+}
+/**
+ * Walk `files`, write their rows to `outPath` and say what was written.
+ *
+ * The file is written beside `outPath` as `<outPath>.partial` and renamed
+ * over it, so a walk that dies leaves no half-written rows file. Every write
+ * goes through a {@link WriteGuard} over the file's directory, which refuses
+ * a directory inside the scanned trees anywhere but beneath `.carrick`.
+ */
+export declare function writePositionRows(options: PositionRowsOptions): PositionRowsCounts;
+/** The kind of row a node gives, if any (exported for the editor-parity test, carrick#2418). */
+export declare function kindOf(node: ts.Node): NodeKind | undefined;