@abide/abide 0.117.1 → 0.117.2

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @abide/abide
 
+## 0.117.2
+
+### Patch Changes
+
+- ea4e27f: a value opening at a member of a name read by name — `reactive(route.url.searchParams.get('book') ?? '')`, `reactive(name.toUpperCase())` — is now a `Reactive` the file reads and writes by name, where before `abide check` refused every write as a string assigned to the `Reactive` and the build rebound the name instead of calling `set`
+- ea4e27f: a value a `refresh({ tags })` marked while nothing read it loads when the next page adopts it — `reactive(() => getMeetings())` on a page visited after the write sends the request and serves the new answer, where it served the answer held before the write and asked nothing (RULEBOOK 13.7)
+
 ## 0.117.1
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abide/abide",
-    "version": "0.117.1",
+    "version": "0.117.2",
     "type": "module",
     "description": "Isomorphic type-safe framework for reactive async interfaces for humans and machines",
     "license": "MIT",

package/src/compiler/ShadowMap.ts

@@ -167,7 +167,7 @@ function copiedFrom(
  * markup, or a read the lowering rewrote. Runs are ascending by where they stand, not by where they
  * came from, so this is a scan.
  */
-function mapForward(
+export function mapForward(
     origins: readonly Origin[],
     position: number,
 ): number | undefined {

package/src/compiler/TypeSession.ts

@@ -38,10 +38,15 @@ import { CHECKED_VALUES } from './Lowering.ts'
 import { diagnosisAt, lineOf } from './lineOf.ts'
 import type { AbideFile } from './parseAbide.ts'
 import { projectShadow, type Span } from './projectShadow.ts'
-import { abideIn } from './reactiveTypes.ts'
+import { type Abide, abideIn, isReactiveType } 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 {
+    CHECKED_SUFFIX,
+    mapForward,
+    SHADOW_SUFFIX,
+    ShadowMap,
+} from './ShadowMap.ts'
 import { SOURCE_SUFFIX } from './splitImports.ts'
 import { type TemplateContext, templateContext } from './templateContext.ts'
 import { templateWarnings } from './templateWarnings.ts'
@@ -711,56 +716,144 @@ export class TypeSession {
         if (queries.every((query) => query === undefined))
             return { answers, warnings }
 
-        const project = await this.currentProject(created, changed)
+        let project = await this.currentProject(created, changed)
         if (project === undefined) return { answers, warnings }
-        const checker = project.checker
-        const abide = await abideIn(project)
-
-        await Promise.all(
-            queries.map(async (query, at) => {
-                if (query === undefined) return
-                const source = sources[at] as (typeof sources)[number]
-                const sourceFile = await project.program.getSourceFile(
+        // Per source, its compiler warnings, the bindings the projection could not type
+        // (`bindingsOfReads`), and those the lowered program proved a `Reactive`.
+        const warned: Diagnosis[][] = sources.map(() => [])
+        const suspects: number[][] = sources.map(() => [])
+        const held: Set<number>[] = sources.map(() => new Set())
+        const answer = async (
+            asked: Project,
+            abide: Abide,
+            at: number,
+        ): Promise<void> => {
+            const query = queries[at]
+            if (query === undefined) return
+            const source = sources[at] as (typeof sources)[number]
+            const sourceFile = await asked.program.getSourceFile(
+                query.map.shadowPath,
+            )
+            // The shadow has to be INSIDE the opened project or the checker never reads it.
+            // Refusing loudly rather than answering nothing: no reads is a file whose every
+            // name lowers as written, which renders `[object Object]` where a value was due —
+            // 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 (RULEBOOK 31.3). Give the app a tsconfig whose include reaches it.`,
+                )
+            const read = await readsIn(
+                asked.checker,
+                abide,
+                sourceFile,
+                query.map.shadowPath,
+                query.spans,
+                source.file,
+                held[at] as Set<number>,
+            )
+            answers[at] = read.answer
+            suspects[at] = read.suspects
+            const placed: Diagnosis[] = []
+            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)
                 )
-                // The shadow has to be INSIDE the opened project or the checker never reads it.
-                // Refusing loudly rather than answering nothing: no reads is a file whose every
-                // name lowers as written, which renders `[object Object]` where a value was due —
-                // 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 (RULEBOOK 31.3). Give the app a tsconfig whose include reaches it.`,
+                    placed.push(
+                        diagnosisAt(
+                            source.path,
+                            source.text,
+                            offset,
+                            'warning',
+                            warning.message,
+                        ),
                     )
-                const read = await readsIn(
-                    checker,
-                    abide,
-                    sourceFile,
-                    query.map.shadowPath,
-                    query.spans,
+            }
+            warned[at] = placed
+        }
+        const every = queries.map((_, at) => at)
+        const first = project
+        const firstAbide = await abideIn(first)
+        await Promise.all(every.map((at) => answer(first, firstAbide, at)))
+        // 31.1 — A BINDING THE PROJECTION TYPED FROM A `Reactive` IS ASKED OF THE PROGRAM IT RUNS
+        // AS: each file holding one is lowered with what it has answered so far, and a binding that
+        // is a `Reactive` there is one in the projection too. A binding typed from one that just
+        // turned out to be a `Reactive` is asked again, until a round turns none. Nothing is asked,
+        // and no second snapshot taken, where no file holds one (`bindingsOfReads`).
+        for (;;) {
+            const asking = every.filter(
+                (at) => (suspects[at] as number[]).length > 0,
+            )
+            if (asking.length === 0) break
+            const loweredCreated: string[] = []
+            const loweredChanged: string[] = []
+            const lowered = asking.map((at) => {
+                const source = sources[at] as (typeof sources)[number]
+                const query = queries[at] as { map: ShadowMap }
+                const shadow = checkedShadow(
                     source.file,
+                    answers[at] as CheckerAnswer,
                 )
-                answers[at] = read.answer
-                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,
-                            ),
-                        )
+                this.register(
+                    query.map.checkedPath,
+                    shadow.text,
+                    loweredCreated,
+                    loweredChanged,
+                )
+                this.openOutside(
+                    source.path,
+                    query.map.checkedPath,
+                    loweredChanged,
+                )
+                return {
+                    at,
+                    path: query.map.checkedPath,
+                    origins: shadow.origins,
                 }
-            }),
-        )
+            })
+            project = await this.currentProject(loweredCreated, loweredChanged)
+            if (project === undefined) return { answers, warnings }
+            const asked = project
+            const abide = await abideIn(asked)
+            const turned = new Set<number>()
+            await Promise.all(
+                lowered.map(async ({ at, path, origins }) => {
+                    const sourceFile = await asked.program.getSourceFile(path)
+                    if (sourceFile === undefined) return
+                    for (const start of suspects[at] as number[]) {
+                        const position = mapForward(origins, start)
+                        if (position === undefined) continue
+                        const symbol = await asked.checker.getSymbolAtLocation(
+                            getTouchingPropertyName(sourceFile, position),
+                        )
+                        const type =
+                            symbol === undefined
+                                ? undefined
+                                : await asked.checker.getTypeOfSymbol(symbol)
+                        if (
+                            type !== undefined &&
+                            (await isReactiveType(
+                                asked.checker,
+                                abide,
+                                type,
+                                false,
+                            ))
+                        ) {
+                            ;(held[at] as Set<number>).add(start)
+                            turned.add(at)
+                        }
+                    }
+                }),
+            )
+            if (turned.size === 0) break
+            await Promise.all([...turned].map((at) => answer(asked, abide, at)))
+            for (const at of asking) if (!turned.has(at)) suspects[at] = []
+        }
+        for (const placed of warned) warnings.push(...placed)
         return { answers, warnings }
     }
 

package/src/compiler/readsIn.ts

@@ -28,6 +28,7 @@ import {
 import {
     type Symbol as CheckedSymbol,
     type Checker,
+    SignatureKind,
     SymbolFlags,
     type Type,
     TypeFlags,
@@ -129,7 +130,9 @@ export async function readsIn(
     shadowPath: string,
     spans: ShadowSpans,
     file: AbideFile,
-): Promise<{ answer: CheckerAnswer; warnings: Finding[] }> {
+    /** Where each name the lowered program proved a `Reactive` starts (`bindingsOfReads`). */
+    held: ReadonlySet<number>,
+): Promise<{ answer: CheckerAnswer; warnings: Finding[]; suspects: number[] }> {
     // A destructuring pattern binds names this does not see, and that is 31.12's case.
     const names: Node[] = []
     const spelled = new Set<string>()
@@ -210,6 +213,12 @@ export async function readsIn(
         ),
     )
     await dropValueHolders(checker, names, reactive)
+    for (let at = 0; at < names.length; at += 1)
+        if (
+            reactive[at] === undefined &&
+            held.has((names[at] as Node).getStart())
+        )
+            reactive[at] = symbols[at]
     // 32.32 — A VALUE WHOSE `reactive(…)` DECLARES `by` keys a `{#for}` over it,
     // wherever the value is declared.
     const byValue = await Promise.all(
@@ -296,7 +305,86 @@ export async function readsIn(
         spans.scripts,
     ))
         warnings.push(warning)
-    return { answer: new CheckerAnswer(reads, statics), warnings }
+    const answer = new CheckerAnswer(reads, statics)
+    return {
+        answer,
+        warnings,
+        suspects: await bindingsOfReads(
+            checker,
+            abide,
+            names,
+            reactive,
+            answer,
+        ),
+    }
+}
+
+/**
+ * Where each binding starts whose type the projection cannot vouch for, for the lowered program to
+ * answer (`TypeSession.classify`).
+ *
+ * 31.1 — A BINDING TYPED FROM A READ IS TYPED FROM THE `Reactive` IN THE PROJECTION, and the read is
+ * of its value. `reactive(route.url.pathname)` asks a `Reactive<URL>` for a `pathname` it does not
+ * declare; the argument is the error type, which `reactive`'s overloads resolve to a `Keyed`, and
+ * the binding then lowered as no `Reactive` at all — `bookId = 'y'` rebinding the name and nothing
+ * waking. Lowered, the argument is `route.url().pathname` and the binding a `Reactive<string>`.
+ *
+ * ONLY A CALL THAT CAN HAND BACK A `Reactive` IS ASKED: an un-annotated binding, not one already,
+ * initialized by a call holding a read, to a callee one of whose signatures returns a `Reactive`.
+ * Anything else is a value however its reads are typed, and asking would cost every page that
+ * computes from one a second snapshot.
+ */
+async function bindingsOfReads(
+    checker: Checker,
+    abide: Abide,
+    names: readonly Node[],
+    reactive: readonly (CheckedSymbol | undefined)[],
+    answer: CheckerAnswer,
+): Promise<number[]> {
+    const suspects: number[] = []
+    const asked: Promise<void>[] = []
+    for (let at = 0; at < names.length; at += 1) {
+        const name = names[at] as Node
+        const declaration = name.parent
+        if (
+            reactive[at] !== undefined ||
+            !isVariableDeclaration(declaration) ||
+            declaration.type !== undefined ||
+            declaration.initializer === undefined
+        )
+            continue
+        let call: Node = declaration.initializer
+        while (TRANSPARENT.has(call.kind))
+            call = (call as unknown as { expression: Node }).expression
+        if (
+            !isCallExpression(call) ||
+            !answer.holdsRead({ start: call.getStart(), end: call.end })
+        )
+            continue
+        const callee = call.expression
+        asked.push(
+            (async () => {
+                const type = await checker.getTypeAtLocation(callee)
+                if (type === undefined) return
+                for (const signature of await checker.getSignaturesOfType(
+                    type,
+                    SignatureKind.Call,
+                )) {
+                    const returned =
+                        await checker.getReturnTypeOfSignature(signature)
+                    if (
+                        returned !== undefined &&
+                        (await isReactiveType(checker, abide, returned, false))
+                    ) {
+                        suspects.push(name.getStart())
+                        return
+                    }
+                }
+            })(),
+        )
+    }
+    await Promise.all(asked)
+    return suspects
 }
 
 /**

package/src/shared/reactive/Reactive.ts

@@ -2219,6 +2219,10 @@ function mirror(cell: Cell, inner: Cell): void {
     // 7.13 through the adoption: the re-settle a rerun of the adopter makes reaches a reload the
     // adopted value owes, rather than finding it unservable and giving up.
     if (inner.owes !== OWES_NOTHING) settleOwed(inner)
+    // 13.7 THROUGH THE ADOPTION TOO: a sweep's mark on a value nothing read is `DIRTY`, and an
+    // adoption is that value's next read. A mirror reached through a rerun finds it resolved
+    // already; the first one `adopt` runs does not, and copied the held value over the mark.
+    if (inner.state !== CLEAN) resolve(inner)
     const adopted = inner.stream
     if (adopted !== null) {
         forwardStream(cell, inner, adopted)