@abide/abide 0.105.1 → 0.107.0

package/src/compiler/argsSchemaOf.ts

@@ -30,6 +30,11 @@ type Schema = { [keyword: string]: JsonValue }
  * class graph instead is wide enough to walk for minutes, and widening it is 19.11's answer.
  */
 export type Walk<Seen = Map<number, Schema>> = { seen: Seen; depth: number }
+/**
+ * A schema walk, and which side of the wire it describes: what a caller SENDS, or what a handler
+ * ANSWERS (19.21).
+ */
+type SchemaWalk = Walk & { result: boolean }
 /** The depth a walk stops at: an object type this deep or deeper is not walked. */
 export const DEEPEST = 8
 
@@ -51,7 +56,11 @@ export async function argsSchemaOf(
     const args =
         call === undefined ? undefined : await checker.getParameterType(call, 0)
     if (args === undefined) return undefined
-    const schema = await schemaOf(checker, args, { seen: new Map(), depth: 0 })
+    const schema = await schemaOf(checker, args, {
+        seen: new Map(),
+        depth: 0,
+        result: false,
+    })
     if (schema.type !== 'object') return undefined
     const required = schema.required as string[] | undefined
     if (required !== undefined && defaulted.length > 0) {
@@ -62,10 +71,30 @@ export async function argsSchemaOf(
     return schema
 }
 
+/**
+ * The JSON Schema of what a handler answers, or `undefined` where it says nothing true of it.
+ *
+ * 19.21 — `value` is what the handler's `Rpc` reads, refusals already out of it. A value that may be
+ * nothing answers 204 rather than JSON, and a value the walk can say nothing of — `unknown`, a
+ * `Response`, a stream, a class instance — publishes no schema rather than `{}`.
+ */
+export async function resultSchemaOf(
+    checker: Checker,
+    value: Type | undefined,
+): Promise<Schema | undefined> {
+    if (value === undefined || (await holdsUndefined(value))) return undefined
+    const schema = await schemaOf(checker, value, {
+        seen: new Map(),
+        depth: 0,
+        result: true,
+    })
+    return Object.keys(schema).length === 0 ? undefined : schema
+}
+
 async function schemaOf(
     checker: Checker,
     type: Type,
-    walk: Walk,
+    walk: SchemaWalk,
 ): Promise<Schema> {
     const flags = type.flags
     if (flags & TypeFlags.String) return { type: 'string' }
@@ -89,7 +118,11 @@ async function schemaOf(
     if (walk.depth >= DEEPEST) return {}
     const pending: Schema = {}
     walk.seen.set(type.id, pending)
-    const inner: Walk = { seen: walk.seen, depth: walk.depth + 1 }
+    const inner: SchemaWalk = {
+        seen: walk.seen,
+        depth: walk.depth + 1,
+        result: walk.result,
+    }
     // Three questions of one type, asked together rather than one round trip after another.
     const [array, tuple, calls] = await Promise.all([
         checker.isArrayType(type),
@@ -113,7 +146,7 @@ async function schemaOf(
 async function objectOf(
     checker: Checker,
     type: Type,
-    walk: Walk,
+    walk: SchemaWalk,
 ): Promise<Schema> {
     const properties: Schema = {}
     const required: string[] = []
@@ -124,6 +157,14 @@ async function objectOf(
         const property = members[at] as (typeof members)[number]
         const value = types[at]
         if (value === undefined) continue
+        // 19.22 — AN ANSWER WITH A METHOD IS AN INSTANCE, and what `JSON.stringify` makes of one is
+        // its own `toJSON`'s or its fields', neither of which its members say.
+        if (
+            walk.result &&
+            (await checker.getSignaturesOfType(value, SignatureKind.Call))
+                .length > 0
+        )
+            return {}
         properties[property.name] = await schemaOf(checker, value, walk)
         // A member JSON can leave out is not required, whether `?` said so or `| undefined` did.
         if (
@@ -136,8 +177,9 @@ async function objectOf(
     if (required.length > 0) schema.required = required
     // 19.18 — A MEMBER THE TYPE DOES NOT DECLARE IS REFUSED, where no index signature declares the
     // rest: a caller outside the process sends whatever it likes, and a body writing its args to a
-    // row would write that too. An author who wants the rest declares a schema of their own.
-    schema.additionalProperties = false
+    // row would write that too. An author who wants the rest declares a schema of their own. 19.22 —
+    // an answer is wider than its type wherever the value handed back was.
+    if (!walk.result) schema.additionalProperties = false
     for (const index of await checker.getIndexInfosOfType(type))
         if (index.keyType.flags & TypeFlags.String)
             schema.additionalProperties = await schemaOf(
@@ -156,7 +198,7 @@ async function objectOf(
 async function unionOf(
     checker: Checker,
     union: UnionOrIntersectionType,
-    walk: Walk,
+    walk: SchemaWalk,
 ): Promise<Schema> {
     const all = await union.getTypes()
     const members: Type[] = []
@@ -182,8 +224,12 @@ async function unionOf(
                     type: 'boolean',
                     const: (member as LiteralType).value as boolean,
                 })
-    for (const member of members)
-        schemas.push(await schemaOf(checker, member, walk))
+    for (const member of members) {
+        const schema = await schemaOf(checker, member, walk)
+        // An arm that says nothing leaves the union saying nothing.
+        if (Object.keys(schema).length === 0) return schema
+        schemas.push(schema)
+    }
     if (schemas.length === 1) return schemas[0] as Schema
     const kinds: string[] = []
     for (const schema of schemas) {

package/src/compiler/checkApp.ts

@@ -1,5 +1,6 @@
 import { relative } from 'node:path' // bun exposes no path helpers of its own
 import { type Placement, placement } from '#server/placement.ts'
+import type { PlacedSource } from './appLayout.ts'
 import { type AppChecker, compiled } from './compileApp.ts'
 import { abideImportsOf } from './componentGraph.ts'
 import { hooksIn } from './hookCalls.ts'
@@ -48,6 +49,7 @@ export async function checkSource(
     const { session, root } = checker
     const layout = await checker.layout()
     // 38.33 — WHAT THE TREE REFUSES OF IT, off the layout the checker keeps until a move is heard.
+    // What the parser refuses is the held text's, below, never the disk's (`layout.unparsed`).
     const tree: Diagnosis[] = []
     for (const refused of layout.refused)
         if (refused.path === path) tree.push(refused)
@@ -116,6 +118,37 @@ export async function checkSource(
     return [...tree, ...own, ...diagnoses]
 }
 
+/**
+ * Lowers every `.abide` of the app into the checker, quietly, as an editor holds it.
+ *
+ * 38.116 — A NAME'S REFERENCES ARE THE WHOLE APP'S, and `checkSource` lowers one page and what it
+ * imports: a page this one never imports, reading the same export, is in no program until it is
+ * lowered. A file the parser refuses is left out, as `checkApp` leaves it.
+ */
+export async function lowerApp(
+    checker: AppChecker,
+    held: (path: string) => string | undefined,
+): Promise<void> {
+    const layout = await checker.layout()
+    const refusals = new Refusals(checker.root, true)
+    const sources: (PlacedSource & { quiet: true })[] = []
+    for (const source of layout.sources) {
+        const editing = held(source.path)
+        if (editing === undefined || editing === source.text) {
+            sources.push({ ...source, quiet: true })
+            continue
+        }
+        const [parsed] = parseSources(
+            [{ path: source.path, text: editing, quiet: true }],
+            refusals,
+        )
+        if (parsed !== undefined)
+            sources.push({ ...source, ...parsed, quiet: true })
+    }
+    const { read } = await readSources(checker.session, sources, refusals)
+    await checker.session.diagnose(read, layout, false)
+}
+
 /** Whether a `.abide` an editor holds calls `onConfig`, where its text parses. */
 function filesConfig(text: string): boolean {
     try {

package/src/compiler/checkedShadow.ts

@@ -43,24 +43,36 @@ export type CheckedShadow = {
  */
 export const COMPONENT_STAND_IN = '__component'
 
+/** 34.16 — the arguments a component is called with: none where no prop is required of it. */
+const COMPONENT_RECORD = '__record'
+
 /**
  * The component a checked module exports as its default: called with the record its tag passes
  * (`projectShadow`'s `invocation`), and answering the `Component` a server module's call of it
  * renders (34.16). What its blocks export by name is beside it.
+ *
+ * `props` is spelled ONCE, between `head` and `tail`, so the one spelling is the one a tag's keys are
+ * contextually typed by, and a caller can copy it from the author's call (38.116).
  */
-function componentModule(props: string, generics?: string): string {
+function componentModule(generics?: string): { head: string; tail: string } {
     // 34.13 — generic over what the file's `<script>` declares, so a caller's props infer it, the
     // signature's own parameters shadowing the opaque stand-ins the body was checked against. 34.16 —
     // a component no prop is required of is called with none, as the runtime's bound face takes it.
     const parameters = generics === undefined ? '' : `<${generics}>`
-    return `
-declare const ${COMPONENT_STAND_IN}: ${parameters}(...record: {} extends ${props} ? [record?: ${props}] : [record: ${props}]) => import('${SERVER_SPECIFIER}').Component
+    return {
+        head: `
+type ${COMPONENT_RECORD}<Props> = {} extends Props ? [record?: Props] : [record: Props]
+declare const ${COMPONENT_STAND_IN}: ${parameters}(...record: ${COMPONENT_RECORD}<`,
+        tail: `>) => import('${SERVER_SPECIFIER}').Component
 export default ${COMPONENT_STAND_IN}
-`
+`,
+    }
 }
 
+const STAND_IN = componentModule()
+
 /** A component nothing has lowered takes anything, which is no finding rather than a wrong one. */
-export const COMPONENT_MODULE = componentModule('any')
+export const COMPONENT_MODULE = `${STAND_IN.head}any${STAND_IN.tail}`
 
 /** The file lowered the way the emitters lower it, for the checker to report on. */
 export function checkedShadow(
@@ -103,7 +115,25 @@ export function checkedShadow(
     }
     origins.push({ at: text.length, source: at, length: source.length - at })
     text += source.slice(at)
-    text += componentModule(propsOf(lowering), file.generics)
+    // 33.4 — WHAT THE CHILD DECLARES IS WHAT A CALLER IS HELD TO: the type `props<X>()` hands back,
+    // read off the call as the author wrote it. 33.3 — `props()` with no argument hands back the
+    // untyped record, and takes anything. 38.116 — AND THE COPY IS PLACED where it was copied from,
+    // so a rename of a prop asked at a tag's key reaches the declaration it is a copy of.
+    const module = componentModule(file.generics)
+    text += module.head
+    const read = lowering.ownPropsRead()
+    if (read === undefined) text += NO_PROPS
+    else {
+        text += 'ReturnType<typeof '
+        const called = source.slice(read.from, read.to).replace(/\(\s*\)$/, '')
+        origins.push({
+            at: text.length,
+            source: read.from,
+            length: called.length,
+        })
+        text += `${called}>`
+    }
+    text += module.tail
     // What each name read by name holds when it is read: what calling it hands back, and through a
     // props accessor, what calling what that hands back does.
     let values = ''
@@ -122,22 +152,6 @@ export function checkedShadow(
     }
 }
 
-/**
- * The props type a caller is held to, spelled off the file's `props` call.
- *
- * 33.4 — WHAT THE CHILD DECLARES IS WHAT A CALLER IS HELD TO: the type `props<X>()` hands back, read
- * off the call as the author wrote it, which stands at the top of the module where this is
- * declared. 33.3 — `props()` with no argument hands back the untyped record, and takes anything.
- */
-function propsOf(lowering: Lowering): string {
-    const read = lowering.ownPropsRead()
-    return read === undefined
-        ? NO_PROPS
-        : `ReturnType<typeof ${lowering.projection.text
-              .slice(read.from, read.to)
-              .replace(/\(\s*\)$/, '')}>`
-}
-
 /**
  * 27.13 — WHAT EACH `onConfig` DEFAULTS IS DECLARED INTO `Config`, so `config().RETRIES` is the
  * `number` its defaults return rather than the index's `unknown`. Each call is bound by the lowering

package/src/compiler/citedClauses.ts

@@ -0,0 +1,14 @@
+/**
+ * Every clause a finding's message cites, in the order it cites them: each number after a
+ * `RULEBOOK`, a list (`RULEBOOK 32.14, 32.32.`) included. What `abide-ignore` answers to (14.19)
+ * and what the editor links (38.118) — one reading, so the two cannot name different clauses.
+ */
+export function citedClauses(message: string): string[] {
+    const clauses: string[] = []
+    for (const citation of message.matchAll(
+        /\bRULEBOOK (\d+\.\d+(?:,\s*\d+\.\d+)*)/g,
+    ))
+        for (const clause of (citation[1] as string).split(/,\s*/))
+            clauses.push(clause)
+    return clauses
+}

package/src/compiler/classifyRead.ts

@@ -103,6 +103,11 @@ export type Read = {
     keys: string[]
     /** 23.9 — the read is abide's `route.params`, which a page or a layout types by its route. */
     routeParams: boolean
+    /**
+     * 32.67 — a read of a `{#for}` row's item: where that row's item binding starts in the
+     * projection, or -1 for every other read.
+     */
+    item: number
 }
 
 /**
@@ -134,6 +139,7 @@ export function newRead(
         local: false,
         keys: [],
         routeParams: false,
+        item: -1,
     }
 }
 

package/src/compiler/classifyTemplate.ts

@@ -84,7 +84,8 @@ export type ClassifiedAttribute = {
     | { kind: 'spread'; explicit: string[] }
     // 32.5, 32.7, 32.8 — the property and the value, kept in step both ways. `reflects` is the
     // attribute the property's value stands at in the tag, and `undefined` where it is not an
-    // attribute: a `<textarea>`'s or `<select>`'s value is the client's to set.
+    // attribute: a `<textarea>`'s value is its text and a `<select>`'s is its options' `selected`,
+    // which the markup writes inside the tag (32.61).
     | {
           kind: 'bound'
           bind: ValueBind
@@ -463,13 +464,15 @@ export function isParserOwned(lowerTag: string): boolean {
 /**
  * The key a component's attribute passes a prop under, or `undefined` where it is no prop.
  *
- * 32.6, 32.10 — a `bind:` handing over a `Reactive` keys the name after it, and any other `:` name
- * — `class:`, `style:`, a `bind:` with nothing bound — is an element's own. The build writes the
+ * 32.6, 32.10, 32.69 — a `bind:` handing over a `Reactive` keys the name after it, and any other
+ * `:` name — `class:`, `style:`, `bind:element`, a `bind:` with nothing bound — is an element's own.
+ * Read as a prop, `bind:element` was one named `element` the child never declared, and the
+ * callback never ran. The build writes the
  * props record by this and the checker projects it by this, so a tag is held to what it sends.
  */
 export function propKeyOf(attribute: Attribute): string | undefined {
     if (attribute.lowerName.startsWith('bind:'))
-        return attribute.expression
+        return attribute.expression && !isElementBind(attribute.lowerName)
             ? attribute.name.slice('bind:'.length)
             : undefined
     return attribute.name.includes(':') ? undefined : attribute.name

package/src/compiler/compileApp.ts

@@ -206,7 +206,7 @@ export async function compiled(
     // ONE LAYOUT for the sources, the handler files and the public files, and what the tree refuses
     // is met before the checker is asked anything.
     const layout = await (kept?.layout() ?? appLayout(root))
-    refusals.adopt(layout.refused)
+    refusals.adopt([...layout.unparsed, ...layout.refused])
     const app: CompiledApp = {
         files: {},
         tables: {},
@@ -534,7 +534,7 @@ ${tableOf(routes)}
 ]
 
 // The router this document gets, the page it arrived on, and the two places a reader navigates
-// from (30.7). Hydrating here rather than leaving it to the app is what makes the page the server
+// from (RULEBOOK 30.7). Hydrating here rather than leaving it to the app is what makes the page the server
 // painted live without anybody wiring it.
 export function start(host: Element) {
     const router = startRouter(routes, host, ${transitions})

package/src/compiler/declaredExports.ts

@@ -35,8 +35,14 @@ import {
 import type { Method } from '#shared/rpc.ts'
 import { aliasedSymbol } from './aliasedSymbol.ts'
 import { defaultedMembers, parameterPattern } from './argsDefaultsIn.ts'
-import { argsSchemaOf, DEEPEST, type Walk } from './argsSchemaOf.ts'
+import {
+    argsSchemaOf,
+    DEEPEST,
+    resultSchemaOf,
+    type Walk,
+} from './argsSchemaOf.ts'
 import { diagnosisAt } from './lineOf.ts'
+import type { Refusals } from './Refusals.ts'
 import { isReactiveCall, METHODS, optionNamed } from './reactiveOptions.ts'
 import {
     abideIn,
@@ -44,7 +50,6 @@ import {
     isReactiveMember,
     valueTypeOf,
 } from './reactiveTypes.ts'
-import type { Refusals } from './Refusals.ts'
 import type { Diagnosis } from './TypeSession.ts'
 
 /**
@@ -83,7 +88,7 @@ export async function declaredExports(
                 refusals.at(
                     file,
                     new Error(
-                        `abide: ${path} is not inside the project ${projectName}, so what it exports cannot be read (16.73). Give the app a tsconfig whose include reaches it.`,
+                        `abide: ${path} is not inside the project ${projectName}, so what it exports cannot be read (RULEBOOK 16.73). Give the app a tsconfig whose include reaches it.`,
                     ),
                 )
                 return undefined
@@ -123,17 +128,21 @@ export async function declaredExports(
                             declared === undefined
                                 ? undefined
                                 : await checker.getTypeOfSymbol(target)
+                        const value =
+                            handlerType === undefined
+                                ? undefined
+                                : await valueOfRpc(checker, handlerType)
                         if (handlerType !== undefined && abide.reactive) {
                             const at = await nestedReactiveIn(
                                 checker,
                                 abide.reactive,
-                                await valueOfRpc(checker, handlerType),
+                                value,
                                 '',
                                 { seen: new Set(), depth: 0 },
                             )
                             if (at !== undefined)
                                 throw new Error(
-                                    `abide: ${path} — \`${exported.name}\` returns a \`Reactive\` at \`${at}\`, which the wire would carry as the function it is rather than the value it holds. Read it there, or return the \`Reactive\` itself to have it adopted (11.12). RULEBOOK 16.39.`,
+                                    `abide: ${path} — \`${exported.name}\` returns a \`Reactive\` at \`${at}\`, which the wire would carry as the function it is rather than the value it holds. Read it there, or return the \`Reactive\` itself to have it adopted (RULEBOOK 11.12). RULEBOOK 16.39.`,
                                 )
                         }
                         return {
@@ -153,6 +162,10 @@ export async function declaredExports(
                                           handlerType,
                                           declared?.defaulted ?? [],
                                       ),
+                            // 19.21 — a stream's chunks are framed one by one, never one JSON value.
+                            result: declared?.copy?.stream
+                                ? undefined
+                                : await resultSchemaOf(checker, value),
                             unread,
                         }
                     } catch (thrown) {
@@ -179,7 +192,15 @@ const METHODS_SOURCE = Bun.fileURLToPath(
 type Declared = Mount['method']
 type DeclaredExport = Pick<
     Mount,
-    'name' | 'ui' | 'cli' | 'mcp' | 'copy' | 'defaults' | 'args' | 'description'
+    | 'name'
+    | 'ui'
+    | 'cli'
+    | 'mcp'
+    | 'copy'
+    | 'defaults'
+    | 'args'
+    | 'result'
+    | 'description'
 > & {
     method: Declared | undefined
     /** 18.15 — what its copy's options declare and the build could not read. */