@abide/abide 0.105.1 → 0.107.0

package/src/compiler/TypeSession.ts

@@ -1,15 +1,24 @@
 import { type Dirent, readdirSync, realpathSync, statSync } from 'node:fs' // Bun exposes no sync directory listing or realpath of its own
 import { basename, dirname, join, resolve } from 'node:path' // Bun exposes no path helpers of its own
-import { type Node, NodeFlags, SyntaxKind } from 'typescript/unstable/ast'
+import {
+    getTouchingPropertyName,
+    type Node,
+    NodeFlags,
+    SyntaxKind,
+} from 'typescript/unstable/ast'
 import {
     API,
     type Symbol as CheckedSymbol,
     type Checker,
+    type CompletionEntry,
     type CompletionInfo,
+    CompletionItemKind,
     NodeBuilderFlags,
     type Project,
     SignatureKind,
+    type Snapshot,
     SymbolFlags,
+    type Type,
 } from 'typescript/unstable/async'
 import { placeOf } from '#server/placement.ts'
 import { aliasedSymbol } from './aliasedSymbol.ts'
@@ -24,15 +33,17 @@ import {
     moduleConfigShadow,
 } from './checkedShadow.ts'
 import type { Finding } from './Finding.ts'
+import { isIgnored } from './isIgnored.ts'
 import { CHECKED_VALUES } from './Lowering.ts'
 import { diagnosisAt, lineOf } from './lineOf.ts'
 import type { AbideFile } from './parseAbide.ts'
-import { projectShadow } from './projectShadow.ts'
+import { projectShadow, type Span } from './projectShadow.ts'
 import { abideIn } from './reactiveTypes.ts'
 import type { ParsedSource, ReadSource } from './readSources.ts'
 import { readsIn, type ShadowSpans } from './readsIn.ts'
 import { CHECKED_SUFFIX, SHADOW_SUFFIX, ShadowMap } from './ShadowMap.ts'
 import { SOURCE_SUFFIX } from './splitImports.ts'
+import { type TemplateContext, templateContext } from './templateContext.ts'
 import { templateWarnings } from './templateWarnings.ts'
 
 // Where 31.3 gets its answer. A `.abide` file is projected into a SHADOW `.ts` held in a virtual
@@ -250,6 +261,52 @@ export class TypeSession {
      * rather than taking a second one.
      */
     private latest: Project | undefined = undefined
+    private latestSnapshot: Snapshot | undefined = undefined
+
+    /**
+     * Snapshots a later one replaced, released once no call is in flight (`hold`).
+     *
+     * THE CHECKER PROCESS KEEPS EVERY SNAPSHOT UNTIL IT IS RELEASED — `updateSnapshot` releases
+     * nothing — and each holds a whole program and checker. Dropped unreleased, a kept session grew
+     * without bound: an `abide lsp` checker reached 59 GB in two hours of watcher-driven snapshots.
+     * Released the moment it is replaced, a question still being answered over it throws, so the
+     * release waits for the last call out.
+     */
+    private retired: Snapshot[] = []
+    private inFlight = 0
+
+    /**
+     * Marks a call in flight until the returned value is disposed (`using`); the last one out
+     * releases what was retired meanwhile. A caller holding a `Project` across calls (`projectWith`)
+     * holds the session for as long.
+     */
+    hold(): Disposable {
+        this.inFlight += 1
+        return {
+            [Symbol.dispose]: () => {
+                this.inFlight -= 1
+                if (this.inFlight === 0) this.releaseRetired()
+            },
+        }
+    }
+
+    private retire(snapshot: Snapshot): void {
+        this.retired.push(snapshot)
+        if (this.inFlight === 0) this.releaseRetired()
+    }
+
+    private releaseRetired(): void {
+        for (const snapshot of this.retired) {
+            // A process that has stopped answering rejects the release, and dies with what it held.
+            const release = snapshot.dispose().catch(() => {})
+            this.releasing.add(release)
+            void release.finally(() => this.releasing.delete(release))
+        }
+        this.retired = []
+    }
+
+    /** Releases sent and not yet answered, which `close` lets finish before ending the connection. */
+    private releasing = new Set<Promise<void>>()
 
     /**
      * Paths edited or deleted on disk since the last snapshot, or `everything`.
@@ -397,10 +454,12 @@ export class TypeSession {
         // after it: a dropped cache re-reads what the project already listed, and a shadow written
         // for a page in a directory it never listed is not among them.
         if (everything)
-            await this.api.updateSnapshot({
-                openProjects: [this.opened],
-                fileChanges: { invalidateAll: true },
-            })
+            this.retire(
+                await this.api.updateSnapshot({
+                    openProjects: [this.opened],
+                    fileChanges: { invalidateAll: true },
+                }),
+            )
         const snapshot = await this.api.updateSnapshot({
             openProjects: [this.opened],
             fileChanges: {
@@ -409,6 +468,8 @@ export class TypeSession {
                 deleted: edits.deleted,
             },
         })
+        if (this.latestSnapshot !== undefined) this.retire(this.latestSnapshot)
+        this.latestSnapshot = snapshot
         this.latest = snapshot.getProjects()[0]
         return this.latest
     }
@@ -457,6 +518,7 @@ export class TypeSession {
     async projectWith(
         modules: readonly string[],
     ): Promise<Project | undefined> {
+        using _held = this.hold()
         const changed: string[] = []
         for (const path of modules) {
             const canonical = this.canonical(path)
@@ -475,7 +537,7 @@ export class TypeSession {
             if (found[at] === undefined) missing.push(modules[at] as string)
         return missing.length === 0
             ? project
-            : this.currentProject(missing, [...missing])
+            : await this.currentProject(missing, [...missing])
     }
 
     /**
@@ -562,6 +624,7 @@ export class TypeSession {
             text?: string
         })[],
     ): Promise<{ answers: CheckerAnswer[]; warnings: Diagnosis[] }> {
+        using _held = this.hold()
         const answered = await this.classify(sources)
         for (let at = 0; at < sources.length; at += 1) {
             const source = sources[at] as (typeof sources)[number]
@@ -639,6 +702,7 @@ export class TypeSession {
                     servers: projection.servers,
                     scripts: projection.scripts,
                     positions: projection.positions,
+                    items: new Set(projection.items.values()),
                 },
             })
         }
@@ -665,7 +729,7 @@ export class TypeSession {
                 // a wrong page, with nothing about it saying so.
                 if (sourceFile === undefined)
                     throw new Error(
-                        `abide: ${source.path} is not inside the project ${this.tsconfig}, so no name in it can be typed (31.3). Give the app a tsconfig whose include reaches it.`,
+                        `abide: ${source.path} is not inside the project ${this.tsconfig}, so no name in it can be typed (RULEBOOK 31.3). Give the app a tsconfig whose include reaches it.`,
                     )
                 const read = await readsIn(
                     checker,
@@ -676,19 +740,25 @@ export class TypeSession {
                     source.file,
                 )
                 answers[at] = read.answer
-                for (const warning of read.warnings)
-                    warnings.push(
-                        diagnosisAt(
-                            source.path,
-                            source.text,
-                            query.map.toSource(
-                                query.map.shadowPath,
-                                warning.at,
-                            ),
-                            'warning',
-                            warning.message,
-                        ),
+                for (const warning of read.warnings) {
+                    const offset = query.map.toSource(
+                        query.map.shadowPath,
+                        warning.at,
+                    )
+                    if (
+                        source.text === undefined ||
+                        !isIgnored(source.text, offset, warning.message)
                     )
+                        warnings.push(
+                            diagnosisAt(
+                                source.path,
+                                source.text,
+                                offset,
+                                'warning',
+                                warning.message,
+                            ),
+                        )
+                }
             }),
         )
         return { answers, warnings }
@@ -707,6 +777,7 @@ export class TypeSession {
         within: string,
         sources: readonly Omit<ParsedSource, 'quiet'>[],
     ): Promise<{ ambient: Diagnosis[]; unkeyed: Diagnosis[] }> {
+        using _held = this.hold()
         const ambient: Diagnosis[] = []
         const unkeyed: Diagnosis[] = []
         const project = await this.currentProject()
@@ -813,6 +884,7 @@ export class TypeSession {
         app: Pick<AppLayout, 'root' | 'addresses' | 'handlers'>,
         scripts = true,
     ): Promise<{ diagnoses: Diagnosis[]; refused: Set<string> }> {
+        using _held = this.hold()
         const within = app.root
         const created: string[] = []
         const changed: string[] = []
@@ -942,8 +1014,18 @@ export class TypeSession {
                             ),
                         ),
                 )
-        const found = [...refused, ...(await Promise.all(reports)).flat()]
-        found.sort(byPlace)
+        const reported = [...refused, ...(await Promise.all(reports)).flat()]
+        reported.sort(byPlace)
+        // A component's props type is checked twice — in its `props` call and in what a tag is held
+        // to (`checkedShadow`) — and both copies place a finding in it at the one place written.
+        const found: Diagnosis[] = []
+        const placed = new Set<string>()
+        for (const diagnosis of reported) {
+            const key = `${diagnosis.path}:${diagnosis.line}:${diagnosis.column}:${diagnosis.code}:${diagnosis.message}`
+            if (placed.has(key)) continue
+            placed.add(key)
+            found.push(diagnosis)
+        }
         return { diagnoses: found, refused: refusing }
     }
 
@@ -976,9 +1058,9 @@ export class TypeSession {
      * The members that may be written at `offset` in a `.abide`, or `undefined` where none can be.
      *
      * 38.98 — ASKED WHERE A HOVER IS (`askedAt`), so `config().` offers the fields 27.13 declared and
-     * a name read by name offers its value's members (31.1). MEMBERS ALONE: at an identifier the
-     * API rejects ("completion list needs auto imports"), which the language server answers as
-     * nothing offered.
+     * a name read by name offers its value's members (31.1). MEMBERS ALONE in a script or an
+     * expression: at an identifier the API rejects ("completion list needs auto imports"), which
+     * the language server answers as nothing offered. Markup is answered apart (38.117).
      */
     async complete(
         path: string,
@@ -986,15 +1068,80 @@ export class TypeSession {
         offset: number,
         triggerCharacter?: string,
     ): Promise<CompletionInfo | undefined> {
+        using _held = this.hold()
+        const template = templateContext(text, offset)
+        if (template !== undefined)
+            return await this.completeTemplate(path, template)
         const at = this.askedAt(path, text, offset)
         if (at === undefined) return undefined
-        return at.project.checker.getCompletionsAtPosition(
+        return await at.project.checker.getCompletionsAtPosition(
             at.asked.path,
             at.asked.position,
             { triggerCharacter },
         )
     }
 
+    /**
+     * 38.117 — what markup offers: a block keyword, a component in scope, or a component's props.
+     *
+     * A PROP IS ASKED OF THE LAST LOWERING, by the component's name: the tag being typed is text the
+     * parser refuses, and the import the name resolves through is the same in the lowering before it.
+     */
+    private async completeTemplate(
+        path: string,
+        template: TemplateContext,
+    ): Promise<CompletionInfo> {
+        const entries: CompletionEntry[] = []
+        if (template.kind !== 'attribute') {
+            const kind =
+                template.kind === 'block'
+                    ? CompletionItemKind.Keyword
+                    : CompletionItemKind.Class
+            for (const name of template.offered) entries.push({ name, kind })
+            return { isIncomplete: false, entries }
+        }
+        const lowered = this.loweredForInspect.get(this.keyOf(path))
+        const project = this.latest
+        if (lowered === undefined || project === undefined)
+            return { isIncomplete: false, entries }
+        const checker = project.checker
+        const found = await checker.resolveName(
+            template.tag,
+            SymbolFlags.Value,
+            { document: lowered.map.shadowPath, position: 0 },
+        )
+        const record =
+            found === undefined
+                ? undefined
+                : await propsRecordOf(
+                      checker,
+                      await aliasedSymbol(checker, found),
+                  )
+        if (record === undefined) return { isIncomplete: false, entries }
+        const unwritten = (await checker.getPropertiesOfType(record)).filter(
+            (prop) => !template.written.includes(prop.name),
+        )
+        for (const entry of await Promise.all(
+            unwritten.map(async (prop) => {
+                const type = await checker.getTypeOfSymbol(prop)
+                return {
+                    name: prop.name,
+                    kind: CompletionItemKind.Property,
+                    detail:
+                        type === undefined
+                            ? undefined
+                            : await checker.typeToString(
+                                  type,
+                                  undefined,
+                                  NodeBuilderFlags.NoTruncation,
+                              ),
+                }
+            }),
+        ))
+            entries.push(entry)
+        return { isIncomplete: false, entries }
+    }
+
     /**
      * The hover signature, documentation and definitions of the name at `offset` in a `.abide`.
      *
@@ -1013,6 +1160,7 @@ export class TypeSession {
         text: string,
         offset: number,
     ): Promise<Inspection | undefined> {
+        using _held = this.hold()
         const at = this.askedAt(path, text, offset)
         if (at === undefined) return undefined
         const { project, asked } = at
@@ -1061,6 +1209,181 @@ export class TypeSession {
         }
     }
 
+    /**
+     * Every place the name at `offset` in a `.abide` is written, across the files the checker holds,
+     * or `undefined` where nothing is named there.
+     *
+     * 38.116 — ASKED OF EVERY PLACE THE CHECKER READS THE OFFSET AT (`ShadowMap.placesFrom`), because
+     * the checked module rewrites a name read by name into another symbol's read: the projection is
+     * where a reactive's markup uses are the declaration's references. A place is kept only where
+     * both layers copied it from the author's text and that text is the name, so scaffolding a
+     * lowering wrote is never a place to rename.
+     *
+     * AND ASKED AGAIN WHERE A REFERENCE IS TEXT THE CHECKED MODULE COPIES TWICE. A component's props
+     * type is a second copy of its `props` call (`checkedShadow`), and a tag's keys are typed by
+     * that copy: the checker answers them as another symbol's references, so a reference landing
+     * on one copy is asked at every place the author's text is read.
+     */
+    async references(
+        path: string,
+        text: string,
+        offset: number,
+    ): Promise<References | undefined> {
+        using _held = this.hold()
+        const lowered = this.loweredForInspect.get(this.keyOf(path))
+        const project = this.latest
+        if (
+            lowered === undefined ||
+            lowered.text !== text ||
+            project === undefined
+        )
+            return undefined
+        const asked = lowered.map.placesFrom(offset)
+        if (asked.length === 0) return undefined
+        const askedAt = new Set<string>()
+        for (const place of asked)
+            askedAt.add(`${place.path}:${place.position}`)
+        let name: Place | undefined
+        let spelled = ''
+        let renamable = true
+        const seen = new Set<string>()
+        const occurrences: Occurrence[] = []
+        for (let index = 0; index < asked.length; index += 1) {
+            const { path: file, position } = asked[index] as {
+                path: string
+                position: number
+            }
+            const sourceFile = await project.program.getSourceFile(file)
+            if (sourceFile === undefined) continue
+            const node = getTouchingPropertyName(sourceFile, position)
+            if (node.kind !== SyntaxKind.Identifier) continue
+            const written = node.getText(sourceFile)
+            if (name === undefined) {
+                const copied = this.copiedSpan(node, written)
+                name = copied === undefined ? undefined : placeOfSpan(copied)
+                spelled = written
+            }
+            const entries = await project.checker.getReferencedSymbolsForNode(
+                node,
+                position,
+            )
+            for (const entry of entries) {
+                const definition = await entry.definition.resolve(project)
+                if (definition === undefined) continue
+                const declaredIn = definition.getSourceFile().fileName
+                if (!this.authored(declaredIn)) renamable = false
+                const declared = (definition as { name?: Node }).name
+                const references = await Promise.all(
+                    entry.references.map((handle) => handle.resolve(project)),
+                )
+                for (const reference of references) {
+                    if (reference === undefined) continue
+                    const copied = this.copiedSpan(reference, written)
+                    if (copied === undefined) continue
+                    const declaration =
+                        declared !== undefined &&
+                        declared.pos === reference.pos &&
+                        declaredIn === reference.getSourceFile().fileName
+                    // Text the checker reads at more than one place is asked at every one.
+                    const copies = copied.map?.placesFrom(copied.start) ?? []
+                    if (copies.length > 2)
+                        for (const place of copies) {
+                            const at = `${place.path}:${place.position}`
+                            if (askedAt.has(at)) continue
+                            askedAt.add(at)
+                            asked.push(place)
+                        }
+                    const placed = placeOfSpan(copied)
+                    const key = `${placed.path}:${placed.start.line}:${placed.start.column}`
+                    if (seen.has(key)) continue
+                    seen.add(key)
+                    const holder = reference.parent
+                    const declaresHolder =
+                        definition.pos === holder.pos &&
+                        declaredIn === reference.getSourceFile().fileName
+                    const shorthand =
+                        holder.kind ===
+                            SyntaxKind.ShorthandPropertyAssignment ||
+                        (holder.kind === SyntaxKind.BindingElement &&
+                            (holder as { propertyName?: Node }).propertyName ===
+                                undefined)
+                    occurrences.push({
+                        ...placed,
+                        declaration,
+                        // A shorthand names a property and a binding at once, and renaming one
+                        // writes the other out beside it: the binding element declares the local
+                        // and the shorthand assignment the property.
+                        shorthand: !shorthand
+                            ? undefined
+                            : declaresHolder ===
+                                (holder.kind === SyntaxKind.BindingElement)
+                              ? 'local'
+                              : 'property',
+                    })
+                }
+            }
+        }
+        if (name === undefined) return undefined
+        return { name, written: spelled, renamable, occurrences }
+    }
+
+    /**
+     * Whether a file the checker read is one an author wrote and can edit: neither a library's
+     * declaration, nor a dependency's, nor scaffolding this session serves that stands for no `.abide`.
+     */
+    private authored(fileName: string): boolean {
+        if (fileName.endsWith('.d.ts') || fileName.includes('/node_modules/'))
+            return false
+        return (
+            ShadowMap.fileFor(this.canonical(fileName)) !== undefined ||
+            !this.shadows.has(this.keyOf(fileName))
+        )
+    }
+
+    /**
+     * Where a node the checker read stands in the file the author wrote, with that file's map where
+     * it is a `.abide`, or `undefined` where the author did not write `name` there: in scaffolding,
+     * or in a file this session serves.
+     */
+    private copiedSpan(node: Node, name: string): CopiedSpan | undefined {
+        const file = node.getSourceFile()
+        let start = node.getStart(file)
+        let end = node.end
+        // A string literal names a property by its text, inside the quotes.
+        if (node.kind === SyntaxKind.StringLiteral) {
+            start += 1
+            end -= 1
+        }
+        const canonical = this.canonical(file.fileName)
+        const abidePath = ShadowMap.fileFor(canonical)
+        if (abidePath === undefined) {
+            if (!this.authored(file.fileName)) return undefined
+            if (file.text.slice(start, end) !== name) return undefined
+            return {
+                path: file.fileName,
+                text: file.text,
+                start,
+                end,
+                map: undefined,
+            }
+        }
+        const lowered = this.loweredForInspect.get(this.keyOf(abidePath))
+        const span = lowered?.map.copiedToSource(canonical, start, end)
+        if (
+            lowered === undefined ||
+            span === undefined ||
+            lowered.text.slice(span.start, span.end) !== name
+        )
+            return undefined
+        return {
+            path: abidePath,
+            text: lowered.text,
+            start: span.start,
+            end: span.end,
+            map: lowered.map,
+        }
+    }
+
     /**
      * A span the checker read, placed in the file the author wrote.
      *
@@ -1120,6 +1443,13 @@ export class TypeSession {
             }
         ).client
         const child = client.process
+        // A release still being written when the connection ends is a write after end, thrown
+        // where nothing catches it. Bounded, for the same process that has stopped answering.
+        if (this.releasing.size > 0)
+            await Promise.race([
+                Promise.allSettled(this.releasing),
+                Bun.sleep(RELEASE_GRACE_MS),
+            ])
         await client.close()
         child?.kill()
     }
@@ -1127,6 +1457,9 @@ export class TypeSession {
 
 const AMBIENT = 'abide-check.d.ts'
 
+// How long `close` waits on releases in flight before ending the connection under them.
+const RELEASE_GRACE_MS = 1000
+
 // What the checker asks for when it resolves an import of `x.abide` (`standIn`).
 const DECLARATION_SUFFIX = '.abide.d.ts'
 // Beside the app's tsconfig, so `extends` and every path in it resolve as they would from there.
@@ -1189,6 +1522,45 @@ export type Inspection = {
     definitions: Place[]
 }
 
+/**
+ * The name under a cursor and every place it is written.
+ *
+ * 38.116 — `name` is where the cursor's own name stands; `renamable` is false where any symbol it
+ * names is declared somewhere an author does not write.
+ */
+export type References = {
+    name: Place
+    /** The name as it is written. */
+    written: string
+    renamable: boolean
+    occurrences: Occurrence[]
+}
+
+/**
+ * One place a name is written: whether it is where the name is declared, and where it is a
+ * shorthand, which side of it a rename renames — the `local` binding or the `property`.
+ */
+export type Occurrence = Place & {
+    declaration: boolean
+    shorthand: 'local' | 'property' | undefined
+}
+
+/** A span of a file the author wrote, and the map of the `.abide` it is in, where it is in one. */
+type CopiedSpan = Span & {
+    path: string
+    text: string
+    map: ShadowMap | undefined
+}
+
+/** A `CopiedSpan` as lines and columns. */
+function placeOfSpan(span: CopiedSpan): Place {
+    return {
+        path: span.path,
+        start: lineOf(span.text, span.start),
+        end: lineOf(span.text, span.end),
+    }
+}
+
 /**
  * The props type a component's tag is held to, printed.
  *
@@ -1198,16 +1570,23 @@ async function propsTypeOf(
     checker: Checker,
     component: CheckedSymbol,
 ): Promise<string> {
+    const record = await propsRecordOf(checker, component)
+    return record === undefined
+        ? 'any'
+        : checker.typeToString(record, undefined, NodeBuilderFlags.NoTruncation)
+}
+
+/** The record a component is called with — the props its tag is held to (33.4). */
+async function propsRecordOf(
+    checker: Checker,
+    component: CheckedSymbol,
+): Promise<Type | undefined> {
     const type = await checker.getTypeOfSymbol(component)
     const call =
         type === undefined
             ? undefined
             : (await checker.getSignaturesOfType(type, SignatureKind.Call))[0]
-    const record =
-        call === undefined ? undefined : await checker.getParameterType(call, 0)
-    return record === undefined
-        ? 'any'
-        : checker.typeToString(record, undefined, NodeBuilderFlags.NoTruncation)
+    return call === undefined ? undefined : checker.getParameterType(call, 0)
 }
 
 /**

package/src/compiler/appLayout.ts

@@ -82,6 +82,11 @@ export type AppLayout = {
     addresses: string[]
     /** What the tree refuses, each at its file; a build stops naming every one. */
     refused: Diagnosis[]
+    /**
+     * What the parser refuses of each `.abide` as the disk holds it, each at its file. Apart from
+     * `refused` because it is the TEXT's: an editor's check parses the text it holds instead (38.34).
+     */
+    unparsed: Diagnosis[]
     /** The resolver every import was followed with, whose answers it keeps. */
     resolve: (specifier: string, from: string) => string | undefined
 }
@@ -99,11 +104,19 @@ export async function appLayout(root: string): Promise<AppLayout> {
     const { abide, handlers, modules, published } = appFiles(root, refusals)
     await refuseModuleHooks(root, modules, refusals)
     const resolve = resolverIn()
+    const unparsed = new Refusals(root, true)
     const own = parseSources(
         await textsAt(abide.map((path) => `${root}/${path}`)),
+        unparsed,
+    )
+    const found = await withDependencies(
+        root,
+        own,
+        handlers,
+        resolve,
         refusals,
+        unparsed,
     )
-    const found = await withDependencies(root, own, handlers, resolve, refusals)
     const invoked = componentGraph(found.sources, resolve).invoked
     const sources: PlacedSource[] = []
     for (const source of found.sources) {
@@ -150,6 +163,7 @@ export async function appLayout(root: string): Promise<AppLayout> {
         mounted: found.mounted,
         addresses: [...addresses].sort(),
         refused: refusals.found,
+        unparsed: unparsed.found,
         resolve,
     }
 }
@@ -182,6 +196,8 @@ export async function withDependencies(
     own: readonly string[],
     resolve: (specifier: string, from: string) => string | undefined,
     refusals: Refusals,
+    /** Where what the parser refuses of a file reached here goes, where apart from `refusals`. */
+    unparsed: Refusals = refusals,
 ): Promise<{
     sources: ParsedSource[]
     handlers: HandlerFile[]
@@ -215,7 +231,7 @@ export async function withDependencies(
             if ((thrown as { code?: unknown }).code === 'ENOENT') return
             throw thrown
         }
-        for (const one of parseSources([{ path, text }], refusals)) {
+        for (const one of parseSources([{ path, text }], unparsed)) {
             byPath.set(one.path, one)
             all.push(one)
         }