@abide/abide 0.41.1 → 0.43.0

package/src/lib/shared/types/Outbox.ts

@@ -0,0 +1,9 @@
+import type { OutboxEntry } from './OutboxEntry.ts'
+
+/*
+The `.outbox` face on a durable RPC's client proxy: callable to read the reactive list
+of undelivered entries (`rpc.outbox()`), with an awaitable `retry()` that drains the whole
+queue and resolves when the replay settles. Server-side there is no client queue, so the
+face is absent.
+*/
+export type Outbox<Args> = (() => OutboxEntry<Args>[]) & { retry: () => Promise<void> }

package/src/lib/shared/types/OutboxEntry.ts

@@ -0,0 +1,27 @@
+/* The lifecycle status of a parked mutation: waiting to (re)send, or currently sending.
+   A write lives in the outbox ONLY while it can't reach the server; the instant the server
+   responds at all — a 2xx OR a real 4xx/500 — the entry leaves the queue, so there is no
+   terminal `error` state. Only the unreachable family (transport failure / 502/503/504/52x)
+   keeps it `queued`. */
+export type OutboxStatus = 'queued' | 'sending'
+
+/* One durable, replayable mutation in an RPC's outbox — parked because the original
+   call couldn't reach the server (transport failure, or a 502/503/504/52x). `controller`
+   is the entry's own abort handle (cancel = `controller.abort()`); `request` is the
+   synthesized, persisted Request the drain re-sends; `args` is the typed input (for
+   rendering); `error` is why it's parked (the `kind: 'queued'` HttpError from the
+   unreachable attempt); `retry()` kicks a FIFO drain. `settled` is the eventual outcome
+   of THIS write as if the original call had reached the server — it resolves with the
+   decoded result on delivery and rejects with the real HttpError on a server refusal (or
+   an AbortError on cancel). It may stay pending indefinitely if the write is never
+   replayed; reading it is what arms it (a never-read `settled` never rejects). */
+export type OutboxEntry<Args> = {
+    id: string
+    controller: AbortController
+    request: Request
+    args: Args
+    status: OutboxStatus
+    error?: unknown
+    retry: () => Promise<void>
+    settled: Promise<unknown>
+}

package/src/lib/shared/types/RawRemoteFunction.ts

@@ -1,4 +1,4 @@
-import type { HttpVerb } from './HttpVerb.ts'
+import type { HttpMethod } from './HttpMethod.ts'
 import type { RemoteCallable } from './RemoteCallable.ts'
 
 /*
@@ -9,6 +9,6 @@ so callers that need status / headers / body streaming or want to
 implement custom error handling can opt out of the decode.
 */
 export type RawRemoteFunction<Args> = RemoteCallable<Args, Response> & {
-    readonly method: HttpVerb
+    readonly method: HttpMethod
     readonly url: string
 }

package/src/lib/shared/types/RemoteCallable.ts

@@ -2,8 +2,8 @@ import type { RpcOptions } from './RpcOptions.ts'
 
 /*
 Call signature shared by RemoteFunction and RawRemoteFunction. The base
-signature keeps `args` required so a schema'd verb can't silently drop its
-input; when `Args` admits undefined (no-input verbs) an intersected
+signature keeps `args` required so a schema'd rpc can't silently drop its
+input; when `Args` admits undefined (no-input rpcs) an intersected
 optional-arg signature lets call sites write `fn()` instead of
 `fn(undefined)`. Intersection rather than a bare conditional so the type
 stays callable while `Args` is still generic (cache() invokes producers

package/src/lib/shared/types/RemoteFunction.ts

@@ -1,7 +1,10 @@
 import type { ClientFlags } from './ClientFlags.ts'
-import type { HttpVerb } from './HttpVerb.ts'
+import type { ErrorSpec } from './ErrorSpec.ts'
+import type { HttpMethod } from './HttpMethod.ts'
+import type { Outbox } from './Outbox.ts'
 import type { RawRemoteFunction } from './RawRemoteFunction.ts'
 import type { RemoteCallable } from './RemoteCallable.ts'
+import type { RpcErrorGuard } from './RpcErrorGuard.ts'
 import type { Subscribable } from './Subscribable.ts'
 
 /*
@@ -25,23 +28,35 @@ HTTP rpc isn't the place for long-lived multi-publisher subscriptions.
 `.fetch(req)` is the framework's request-dispatch entry point — used by
 the router to invoke the handler from an incoming HTTP request, not
 for user code.
-`crossOrigin` (server-side only, set via the verb's opts) exempts a
-mutating verb from the router's same-origin CSRF gate, accepting browser
+`crossOrigin` (server-side only, set via the rpc's opts) exempts a
+mutating rpc from the router's same-origin CSRF gate, accepting browser
 requests whose Origin doesn't match the app's own host.
 */
 /*
-A body verb (POST/PUT/PATCH) also accepts a FormData in place of typed args:
+A body rpc (POST/PUT/PATCH) also accepts a FormData in place of typed args:
 buildRpcRequest ships it as a multipart body and the server splits text fields
 into args (still schema-validated) and File parts into files(). FormData is
 stringly-typed, so this is the upload escape hatch — typed object args remain
 the default for everything else.
 */
-export type RemoteFunction<Args, Return> = RemoteCallable<Args, Return> & {
-    readonly method: HttpVerb
+export type RemoteFunction<
+    Args,
+    Return,
+    Errors extends ErrorSpec = Record<never, never>,
+> = RemoteCallable<Args, Return> & {
+    readonly method: HttpMethod
     readonly url: string
     readonly clients: ClientFlags
     readonly crossOrigin?: boolean
     readonly raw: RawRemoteFunction<Args>
     stream(args?: Args | FormData): Subscribable<Return>
     fetch(request: Request): Promise<Response>
+    /* Type-guard a caught error against this rpc's declared `errors` (plus the framework
+       `'validation'` / `'queued'`): narrows `.kind` and, for a known kind, `.data` — the
+       per-rpc replacement for a global guard, since the error name → data type mapping
+       lives in the rpc's own spec. */
+    readonly isError: RpcErrorGuard<Errors>
+    /* Present only on a durable (`outbox`) RPC's client proxy: callable for the reactive
+       list of undelivered entries, with `retry()` to drain the queue. Undefined otherwise. */
+    readonly outbox?: Outbox<Args>
 }

package/src/lib/shared/types/RequestScopeInfo.ts

@@ -3,7 +3,7 @@ import type { TraceContext } from './TraceContext.ts'
 /*
 The request-scope facts the shared layer reads through requestScopeSlot:
 trace position, elapsed ms since the scope opened (request start on the
-server, navigation start in the browser), and the verb+path that anchors log
+server, navigation start in the browser), and the method+path that anchors log
 lines. Resolved fresh per read so `elapsedMs` is current at the call.
 */
 export type RequestScopeInfo = {

package/src/lib/shared/types/RpcErrorGuard.ts

@@ -0,0 +1,40 @@
+import type { HttpError } from '../HttpError.ts'
+import type { ErrorSpec } from './ErrorSpec.ts'
+import type { OutboxEntry } from './OutboxEntry.ts'
+import type { StandardSchemaV1 } from './StandardSchemaV1.ts'
+import type { ValidationErrorData } from './ValidationErrorData.ts'
+
+/* The payload a declared error name carries: its data schema's inferred input, or
+   `unknown` for a nullary error (no data schema). */
+type DeclaredErrorData<
+    Errors extends ErrorSpec,
+    Name extends keyof Errors,
+> = Errors[Name]['data'] extends StandardSchemaV1
+    ? StandardSchemaV1.InferInput<Errors[Name]['data']>
+    : unknown
+
+/*
+A rpc's `isError` guard — branch a caught error on a kind THIS rpc knows, with the
+data type narrowed from the rpc's own `errors` spec. `rpc.isError(err, 'outOfStock')`
+narrows `.data` to that error's payload; the framework-reserved `'validation'` /
+`'queued'` to their fixed shapes; any other string narrows `.kind` only (`.data`
+stays `unknown` — it belongs to a different rpc, whose type isn't in scope here).
+
+The declared-name overload comes first so an app error shadows the reserved ones on a
+name collision, and so the kind argument autocompletes to the rpc's declared names.
+*/
+export interface RpcErrorGuard<Errors extends ErrorSpec> {
+    <Name extends keyof Errors & string>(
+        error: unknown,
+        kind: Name,
+    ): error is HttpError & { kind: Name; data: DeclaredErrorData<Errors, Name> }
+    (
+        error: unknown,
+        kind: 'validation',
+    ): error is HttpError & { kind: 'validation'; data: ValidationErrorData }
+    (
+        error: unknown,
+        kind: 'queued',
+    ): error is HttpError & { kind: 'queued'; data: OutboxEntry<unknown> }
+    <Kind extends string>(error: unknown, kind: Kind): error is HttpError & { kind: Kind }
+}

package/src/lib/shared/types/RpcInvoker.ts

@@ -1,4 +1,4 @@
-/* A verb invoker mirrors the verb's own call: a plain call decodes the body
+/* A rpc invoker mirrors the rpc's own call: a plain call decodes the body
    (throws HttpError on non-2xx), `.raw` returns the Response untouched. Shared
    by every name→callable RPC proxy (the CLI client, the test harness). */
 export type RpcInvoker = ((args?: unknown) => Promise<unknown>) & {

package/src/lib/shared/types/StandardSchemaV1.ts

@@ -2,7 +2,7 @@
 Mirror of the Standard Schema v1 spec interface (standardschema.dev). Any
 library that implements the spec — zod, valibot, arktype, etc. — produces
 values whose `~standard` property structurally matches this shape, so users
-can pass their existing schemas to verb helpers without an adapter.
+can pass their existing schemas to rpc helpers without an adapter.
 
 Kept inline (no `@standard-schema/spec` dep) because the spec is type-only
 and tiny; adding a package for ~30 lines of interface would be churn. The

package/src/lib/shared/types/ValidationErrorData.ts

@@ -0,0 +1,20 @@
+import type { StandardSchemaV1 } from './StandardSchemaV1.ts'
+
+/*
+The `data` payload an input/file validation failure carries on its HttpError —
+`kind: 'validation'`, status 422. `issues` is the raw Standard Schema issue list
+(every message + full path); `fields` is the form-friendly top-level-field →
+first-message map (fieldErrorsFromIssues). Because a throw can't carry the rpc's
+per-kind type to the catch, `HttpError.data` is typed `unknown` — narrow it with
+this when `err.kind === 'validation'`:
+
+  if (err instanceof HttpError && err.kind === 'validation') {
+      const { fields } = err.data as ValidationErrorData
+      // fields.email === 'Required', …
+  }
+*/
+// @documentation response
+export type ValidationErrorData = {
+    readonly issues: readonly StandardSchemaV1.Issue[]
+    readonly fields: Record<string, string>
+}

package/src/lib/shared/url.ts

@@ -11,7 +11,7 @@ type Query = Record<string, QueryValue>
 /*
 Augmentable rpc map. Codegen emits a `declare module '<importName>/shared/url'`
 block filling this with `'/rpc/<file>': args` for each query-carrying (GET)
-verb, so url('/rpc/search', { q }) types its args against the verb's own
+rpc, so url('/rpc/search', { q }) types its args against the rpc's own
 signature. Empty by default — an absent entry falls through to the page/asset
 branch, so the helper works before the generated d.ts lands.
 */
@@ -47,7 +47,7 @@ no bracket segments yields {}, which collapses the params slot away. The
 catch-all branch recurses on its head too, so `[name]` segments before a
 `[...rest]` are kept.
 */
-type PathParams<P extends string> = P extends `${infer Head}[...${infer Rest}]${infer Tail}`
+export type PathParams<P extends string> = P extends `${infer Head}[...${infer Rest}]${infer Tail}`
     ? PathParams<Head> & { [K in Rest]: string | number } & PathParams<Tail>
     : P extends `${string}[${infer Name}]${infer Tail}`
       ? { [K in Name]: string | number } & PathParams<Tail>
@@ -59,7 +59,7 @@ Resolves any in-app URL to its base-correct, typed form — the single chokepoin
 so a project mounted under APP_URL's subpath (e.g. /v2) generates links, asset
 refs, and rpc hrefs that stay within the mount. Three disjoint URL kinds, keyed
 off the path:
-  - rpc (flat /rpc/*, present in RpcRoutes): the verb's args, serialised to query.
+  - rpc (flat /rpc/*, present in RpcRoutes): the rpc's args, serialised to query.
   - page route (has [name] segments): path params, then optional query.
   - asset / paramless / raw: bare path, then optional query.
 External URLs (scheme-qualified or protocol-relative) skip the base untouched,

package/src/lib/shared/writeRpcDts.ts

@@ -1,15 +1,15 @@
 import { carriesBodyArgs } from './carriesBodyArgs.ts'
-import { detectVerbMethod } from './detectVerbMethod.ts'
+import { detectRpcMethod } from './detectRpcMethod.ts'
 import { fileStem } from './fileStem.ts'
 import { rpcUrlForFile } from './rpcUrlForFile.ts'
 import { writeDts } from './writeDts.ts'
 
 /*
 Emits a `.d.ts` that augments abide's `RpcRoutes` interface with one entry per
-query-carrying $rpc verb, so `url('/rpc/search', { q })` types its args against
-the verb's own signature. Only GET/DELETE/HEAD (non-body) verbs are included —
-a url() can carry a query string but not a request body, so a POST verb has no
-URL form. `RpcArgs` lifts the args type out of the verb's RemoteFunction
+query-carrying $rpc rpc, so `url('/rpc/search', { q })` types its args against
+the rpc's own signature. Only GET/DELETE/HEAD (non-body) rpcs are included —
+a url() can carry a query string but not a request body, so a POST rpc has no
+URL form. `RpcArgs` lifts the args type out of the rpc's RemoteFunction
 (dropping the FormData upload variant); the file path resolves the export by
 its filename, the abide one-export-per-file convention. Written to
 `src/.abide/rpc.d.ts` so the consumer's src tsconfig include picks it up, keyed
@@ -28,8 +28,8 @@ export async function writeRpcDts({
 }): Promise<void> {
     const lines = await Promise.all(
         rpcFiles.map(async (file) => {
-            const method = detectVerbMethod(await Bun.file(`${rpcDir}/${file}`).text())
-            // A body verb's args can't ride a URL — leave it out of the url() rpc map.
+            const method = detectRpcMethod(await Bun.file(`${rpcDir}/${file}`).text())
+            // A body rpc's args can't ride a URL — leave it out of the url() rpc map.
             if (!method || carriesBodyArgs(method)) {
                 return undefined
             }

package/src/lib/shared/writeTestRpcDts.ts

@@ -5,9 +5,9 @@ import { writeDts } from './writeDts.ts'
 
 /*
 Emits a `.d.ts` that augments createTestApp's `RpcClient` interface with one
-entry per $rpc verb, keyed by command name (the same key `app.rpc.<name>`
-resolves at runtime). Each entry lifts the verb's args + resolved return out of
-its RemoteFunction so `app.rpc.getProduct({ id })` types against the verb's own
+entry per $rpc rpc, keyed by command name (the same key `app.rpc.<name>`
+resolves at runtime). Each entry lifts the rpc's args + resolved return out of
+its RemoteFunction so `app.rpc.getProduct({ id })` types against the rpc's own
 signature — args in, decoded body out, plus `.raw` for the Response. `RpcArgs`
 drops the FormData upload variant exactly as writeRpcDts does; `RpcReturn`
 reads the resolved body type. Written to `src/.abide/testRpc.d.ts` so the

package/src/lib/test/createTestApp.ts

@@ -25,7 +25,7 @@ import { rpc } from '../../_virtual/rpc.ts'
 import { shell } from '../../_virtual/shell.ts'
 // @ts-expect-error virtual module resolved by abideResolverPlugin
 import { sockets } from '../../_virtual/sockets.ts'
-import { verbRegistry } from '../server/rpc/verbRegistry.ts'
+import { rpcRegistry } from '../server/rpc/rpcRegistry.ts'
 import { createServer } from '../server/runtime/createServer.ts'
 import { ensureRegistriesLoaded } from '../server/runtime/registryManifests.ts'
 import { requestContext } from '../server/runtime/requestContext.ts'
@@ -46,8 +46,8 @@ import type { RemoteFunction } from '../shared/types/RemoteFunction.ts'
 import { createTestSocketChannel } from './createTestSocketChannel.ts'
 
 /*
-Augmentable verb/socket maps for `app.rpc.<verb>` / `app.sockets.<name>`. The
-build's writeTestRpcDts / writeTestSocketsDts emit one entry per verb/socket
+Augmentable rpc/socket maps for `app.rpc.<rpc>` / `app.sockets.<name>`. The
+build's writeTestRpcDts / writeTestSocketsDts emit one entry per rpc/socket
 (into src/.abide/), so the keys + signatures are the project's real surface
 with no imports. Empty here; types arrive once the app has been built. Mirrors
 url's RpcRoutes / health's AppHealthMap.
@@ -58,7 +58,7 @@ export interface RpcClient {}
 // biome-ignore lint/suspicious/noEmptyInterface: augmented by the generated testSockets.d.ts
 export interface SocketClient {}
 
-/* The booted app under test. Every named subsystem is reachable as the verb
+/* The booted app under test. Every named subsystem is reachable as the rpc
    you call, the socket you iterate, or a path you fetch — over the real
    server, so the full pipeline (CSRF, cookies, base path) runs. */
 export type TestApp = {
@@ -69,7 +69,7 @@ export type TestApp = {
        matches routes at raw paths — the APP_URL mount base is stripped by an
        external proxy in production, absent here — so paths carry no base. */
     fetch: (path: string, init?: RequestInit) => Promise<Response>
-    /* Verb calls over HTTP, keyed by command name: `app.rpc.getProduct({ id })`. */
+    /* Rpc calls over HTTP, keyed by command name: `app.rpc.getProduct({ id })`. */
     rpc: RpcClient
     /* Sockets keyed by name: `app.sockets.ticker` is the Socket — iterate it for
        the live stream, `.tail(n)` to seed, `.publish(m)` to send. */
@@ -88,7 +88,7 @@ export type TestApp = {
 Boots the real app on an ephemeral port — the same wiring serverEntry performs,
 minus the standalone-binary env layers. Imports the framework's virtual
 manifests (resolved by abideResolverPlugin, registered via `abide/preload`
-in the consumer's bunfig), so the routes, verbs, and sockets are the project's
+in the consumer's bunfig), so the routes, rpcs, and sockets are the project's
 real surface, not a fixture. Pass nothing: `await createTestApp()` is the app
 exactly as `bun start` would serve it.
 
@@ -138,19 +138,19 @@ export async function createTestApp(): Promise<TestApp> {
         return fetch(`${origin}${path}`, init)
     }
 
-    /* Verb modules loaded once so the registry holds every RemoteFunction; the
+    /* Rpc modules loaded once so the registry holds every RemoteFunction; the
        proxy maps command name → an HTTP call against the booted server. */
     await ensureRegistriesLoaded()
     const remotes = new Map<string, RemoteFunction<unknown, unknown>>(
-        Array.from(verbRegistry.values()).map((entry) => [
+        Array.from(rpcRegistry.values()).map((entry) => [
             commandNameForUrl(entry.remote.url),
             entry.remote,
         ]),
     )
 
     function send(remote: RemoteFunction<unknown, unknown>, args: unknown): Promise<Response> {
-        /* Same-origin Origin header so the CSRF gate admits mutating verbs; the
-           server serves verbs at their raw url (no mount base applied here). */
+        /* Same-origin Origin header so the CSRF gate admits mutating rpcs; the
+           server serves rpcs at their raw url (no mount base applied here). */
         const request = buildRpcRequest({
             method: remote.method,
             url: remote.url,

package/src/lib/ui/compile/ABIDE_SEMANTIC_TOKENS_LEGEND.ts

@@ -0,0 +1,45 @@
+/*
+The LSP semantic-tokens legend abide lsp advertises, and the decoder from
+TypeScript's encoded classifications to legend names. TypeScript encodes a
+classification as `((tokenType + 1) << 8) + modifierBitset`; its TokenType and
+TokenModifier enums fix the orders below. `keyword`/`operator` carry the `{#…}`
+block framing the structural tokenizer emits.
+*/
+
+/* TS TokenType order (class=0 … member=11) → LSP token-type name. */
+const TS_TYPE_TO_LSP = [
+    'class',
+    'enum',
+    'interface',
+    'namespace',
+    'typeParameter',
+    'type',
+    'parameter',
+    'variable',
+    'enumMember',
+    'property',
+    'function',
+    'method',
+]
+
+/* TS TokenModifier order (declaration=bit 0 … local=bit 5). */
+const TS_MODIFIERS = ['declaration', 'static', 'async', 'readonly', 'defaultLibrary', 'local']
+
+export const ABIDE_SEMANTIC_TOKENS_LEGEND = {
+    tokenTypes: [...TS_TYPE_TO_LSP, 'keyword', 'operator'],
+    tokenModifiers: TS_MODIFIERS,
+}
+
+/* Decodes one TypeScript encoded classification into legend names. */
+export function mapTsClassification(
+    classification: number,
+): { type: string; modifiers: string[] } | undefined {
+    const tokenType = (classification >> 8) - 1
+    const type = TS_TYPE_TO_LSP[tokenType]
+    if (type === undefined) {
+        return undefined
+    }
+    const modifierSet = classification & 255
+    const modifiers = TS_MODIFIERS.filter((_, bit) => (modifierSet & (1 << bit)) !== 0)
+    return { type, modifiers }
+}

package/src/lib/ui/compile/abideUiPlugin.ts

@@ -1,5 +1,6 @@
 import { relative } from 'node:path'
 import type { BunPlugin } from 'bun'
+import { fileName } from '../../shared/fileName.ts'
 import { messageFromError } from '../../shared/messageFromError.ts'
 import { AbideCompileError } from './AbideCompileError.ts'
 import { analyzeComponent } from './analyzeComponent.ts'
@@ -42,7 +43,7 @@ export const abideUiPlugin: BunPlugin = {
         build.onLoad({ filter: /\.abide$/ }, async (args) => {
             const source = await Bun.file(args.path).text()
             const moduleId = relative(nearestProjectRoot(args.path, process.cwd()), args.path)
-            const isLayout = (args.path.split('/').pop() ?? '') === 'layout.abide'
+            const isLayout = fileName(args.path) === 'layout.abide'
             /* Bun frames a plugin throw at `<file>:0` regardless of the real spot, so
                carry the component path + resolved line:col in the message — otherwise a
                control-flow / compile error reads as `:0` and (in deep imports) can look

package/src/lib/ui/compile/awaitPlan.ts

@@ -0,0 +1,48 @@
+import { resolveBranches } from './resolveBranches.ts'
+import type { TemplateNode } from './types/TemplateNode.ts'
+
+/* The structural shape of an `await` block, resolved ONCE from the node so the build and
+   SSR back-ends share one reading of it and only own emission. Both previously recomputed
+   branch resolution, the `finallyChildren` default, the blocking-vs-streaming split of the
+   resolved content/binding, and the surface-the-rejection rule — the parts that can silently
+   diverge. Same single-source-of-truth model the positional walks already use. */
+export type AwaitPlan = {
+    /* `then` on the tag → blocking: no pending branch, the children ARE the resolved content
+       (settled before first flush). Absent → streaming: pending flushes, `then` resolves later. */
+    blocking: boolean
+    /* The pending content (streaming) — `[]` when blocking. */
+    pending: TemplateNode[]
+    /* The resolved content + its bound name: the children-minus-branch bound to `node.as`
+       when blocking, the `then` branch bound to its `as` when streaming. `_value` default. */
+    resolvedChildren: TemplateNode[]
+    resolvedAs: string
+    /* The catch content + its bound name (`_error` default); empty when no catch branch. */
+    catchChildren: TemplateNode[]
+    catchAs: string
+    finallyChildren: TemplateNode[]
+    /* Neither catch nor finally → a rejection must surface (re-throw / `undefined` catch thunk)
+       instead of rendering an empty branch. */
+    surfaceRejection: boolean
+}
+
+/* Resolves an `await` node's branches into the shared structural plan. */
+export function awaitPlan(node: Extract<TemplateNode, { kind: 'await' }>): AwaitPlan {
+    const [thenBranch, catchBranch, finallyBranch] = resolveBranches(
+        node,
+        'then',
+        'catch',
+        'finally',
+    )
+    const finallyChildren = finallyBranch?.children ?? []
+    const nonBranch = node.children.filter((child) => child.kind !== 'branch')
+    return {
+        blocking: node.blocking,
+        pending: node.blocking ? [] : nonBranch,
+        resolvedChildren: node.blocking ? nonBranch : (thenBranch?.children ?? []),
+        resolvedAs: (node.blocking ? node.as : thenBranch?.as) ?? '_value',
+        catchChildren: catchBranch?.children ?? [],
+        catchAs: catchBranch?.as ?? '_error',
+        finallyChildren,
+        surfaceRejection: catchBranch === undefined && finallyChildren.length === 0,
+    }
+}