@abide/abide 0.58.0 → 0.100.0

package/src/server/testBuild.ts

@@ -0,0 +1,237 @@
+// 42.16 — UNDER `bun test`, `createApp` BUILDS THE APP rather than reading whatever `abide build` last
+// left, ONCE PER STATE OF ITS SOURCES: the build's directory is named after a hash of what made it,
+// so a build either matches the sources or does not exist, and every test process — every
+// `--parallel` worker, every spawned child — reuses the one that does. Eight workers each building
+// their own copy of a 1.3 s build waited 7–10 s apiece.
+
+import { mkdir, rename, rm, utimes, writeFile } from 'node:fs/promises' // bun exposes no directory creation, rename, removal, mtime write or exclusive create of its own
+import { dirname } from 'node:path' // bun exposes no path helpers of its own
+import { namesUnder } from './namesUnder.ts'
+
+// The CLI, spawned rather than imported: the compiler is not reachable from the server seam.
+const ABIDE_BIN = Bun.fileURLToPath(
+    new URL('../../bin/abide.ts', import.meta.url),
+)
+// The framework's own source is part of what made a build: a compiler change is a new build.
+const FRAMEWORK = Bun.fileURLToPath(new URL('../..', import.meta.url))
+const POLL_MS = 50
+// A build no test process has reused for this long is swept by the next one that builds.
+const UNUSED_FOR_MS = 24 * 60 * 60 * 1000
+
+// One lookup per app per test process, however many files in it call `createApp`.
+const TEST_BUILDS = new Map<string, Promise<string>>()
+
+/**
+ * The build of the app under `root` for its sources as they stand, made if no process has made it.
+ *
+ * UNDER `node_modules`, so a bare import in the built modules resolves as it does from the app, and
+ * so it is ignored wherever `node_modules` is.
+ */
+export function testBuild(root: string): Promise<string> {
+    let built = TEST_BUILDS.get(root)
+    if (built === undefined) {
+        built = sourceHash(root).then((key) =>
+            sharedBuild(
+                `${dirname(root)}/node_modules/.cache/abide`,
+                `build-${key}`,
+                (out) => runBuild(root, out),
+            ),
+        )
+        TEST_BUILDS.set(root, built)
+    }
+    return built
+}
+
+/**
+ * `builds/key`, made by `build` in exactly one process however many ask at once.
+ *
+ * THE FIRST TO CREATE `key.lock` BUILDS — an exclusive create is atomic, so one process wins — into
+ * a staging directory renamed into place, so nothing reads a half-written build. The rest wait for
+ * it, and take the lock over if the process holding it has ended.
+ */
+export async function sharedBuild(
+    builds: string,
+    key: string,
+    build: (out: string) => Promise<void>,
+): Promise<string> {
+    const out = `${builds}/${key}`
+    const lock = `${out}.lock`
+    await mkdir(builds, { recursive: true })
+    for (;;) {
+        if (await isDirectory(out)) {
+            const now = new Date()
+            await utimes(out, now, now)
+            return out
+        }
+        if (await claim(lock)) {
+            try {
+                if (!(await isDirectory(out))) await buildInto(out, build)
+            } finally {
+                await rm(lock, { force: true })
+            }
+            await sweep(builds, key)
+            return out
+        }
+        if (await holderEnded(lock)) await rm(lock, { force: true })
+        else await Bun.sleep(POLL_MS)
+    }
+}
+
+async function buildInto(
+    out: string,
+    build: (out: string) => Promise<void>,
+): Promise<void> {
+    const staging = `${out}.tmp-${process.pid}`
+    await rm(staging, { recursive: true, force: true })
+    try {
+        await build(staging)
+        await rename(staging, out)
+    } catch (thrown) {
+        await rm(staging, { recursive: true, force: true })
+        // TWO HOLDERS, where one took over a lock the other had just taken over: the first rename
+        // stands, and it is the same build.
+        if (await isDirectory(out)) return
+        throw thrown
+    }
+}
+
+async function runBuild(root: string, out: string): Promise<void> {
+    const child = Bun.spawn(
+        [process.execPath, ABIDE_BIN, 'build', '--root', root, '--out', out],
+        { stdout: 'ignore', stderr: 'pipe' },
+    )
+    const [exitCode, said] = await Promise.all([
+        child.exited,
+        new Response(child.stderr).text(),
+    ])
+    if (exitCode !== 0)
+        throw new Error(
+            `abide: createApp could not build the app under ${root} for this test run.\n${said}`,
+        )
+}
+
+/**
+ * A hash of everything a build of the app under `root` is made from.
+ *
+ * The app's files, the package and lockfile above it, the framework's own source, and `root`
+ * itself, since a build carries the paths it was made at.
+ */
+export async function sourceHash(root: string): Promise<string> {
+    const app = dirname(root)
+    const paths = [
+        ...filesUnder(root),
+        ...filesUnder(`${FRAMEWORK}src`),
+        ...filesUnder(`${FRAMEWORK}bin`),
+        `${app}/package.json`,
+        `${app}/tsconfig.json`,
+    ]
+    const lockfile = await lockfileAbove(app)
+    if (lockfile !== undefined) paths.push(lockfile)
+    const contents = await Promise.all(
+        paths.map((path) =>
+            Bun.file(path)
+                .bytes()
+                .catch(() => undefined),
+        ),
+    )
+    const hasher = new Bun.CryptoHasher('sha256')
+    hasher.update(root)
+    for (let at = 0; at < paths.length; at += 1) {
+        const bytes = contents[at]
+        if (bytes === undefined) continue
+        hasher.update(paths[at] as string)
+        hasher.update(bytes)
+    }
+    return hasher.digest('hex').slice(0, 16)
+}
+
+// Sorted, so the hash does not depend on the order a directory lists in. Dot entries and
+// `node_modules` are skipped: neither is the app's source, and the builds live in one.
+function filesUnder(directory: string): string[] {
+    const found: string[] = []
+    for (const name of namesUnder(directory))
+        if (!`/${name}`.includes('/node_modules/'))
+            found.push(`${directory}/${name}`)
+    return found.sort()
+}
+
+async function lockfileAbove(directory: string): Promise<string | undefined> {
+    for (let at = directory; ; at = dirname(at)) {
+        for (const name of ['bun.lock', 'bun.lockb'])
+            if (await Bun.file(`${at}/${name}`).exists()) return `${at}/${name}`
+        if (dirname(at) === at) return undefined
+    }
+}
+
+async function claim(lock: string): Promise<boolean> {
+    try {
+        await writeFile(lock, String(process.pid), { flag: 'wx' })
+        return true
+    } catch (thrown) {
+        if ((thrown as { code?: string }).code === 'EEXIST') return false
+        throw thrown
+    }
+}
+
+async function holderEnded(lock: string): Promise<boolean> {
+    const text = await Bun.file(lock)
+        .text()
+        .catch(() => undefined)
+    // Gone is not ended: the holder finished, and the next pass finds its build.
+    if (text === undefined) return false
+    // Empty is a holder between creating the lock and writing its pid.
+    return text !== '' && !isRunning(Number(text))
+}
+
+/** Removes builds unused for a day, and what an ended process left half-made. */
+async function sweep(builds: string, kept: string): Promise<void> {
+    const names = new Bun.Glob('*').scanSync({ cwd: builds, onlyFiles: false })
+    const removals: Promise<void>[] = []
+    const now = Date.now()
+    for (const name of names) {
+        if (name === kept) continue
+        const staged = /\.tmp-(\d+)$/.exec(name)
+        if (staged !== null) {
+            if (!isRunning(Number(staged[1])))
+                removals.push(
+                    rm(`${builds}/${name}`, { recursive: true, force: true }),
+                )
+            continue
+        }
+        if (name.endsWith('.lock')) continue
+        removals.push(
+            Bun.file(`${builds}/${name}`)
+                .stat()
+                .then((found) =>
+                    now - found.mtimeMs > UNUSED_FOR_MS
+                        ? rm(`${builds}/${name}`, {
+                              recursive: true,
+                              force: true,
+                          })
+                        : undefined,
+                )
+                .catch(() => undefined),
+        )
+    }
+    await Promise.all(removals)
+}
+
+async function isDirectory(path: string): Promise<boolean> {
+    return (
+        (
+            await Bun.file(path)
+                .stat()
+                .catch(() => undefined)
+        )?.isDirectory() === true
+    )
+}
+
+function isRunning(pid: number): boolean {
+    try {
+        process.kill(pid, 0)
+        return true
+    } catch (thrown) {
+        // EPERM is a process that exists and is someone else's.
+        return (thrown as { code?: string }).code === 'EPERM'
+    }
+}

package/src/server/trace.ts

@@ -0,0 +1,151 @@
+// SECTION 24 — TRACING, in the W3C trace-context format: `traceparent` in, `traceparent` out, and
+// `traceresponse` on the answer (21.2). A span is a log line (24.3), so there is no second feed to
+// subscribe to — `log.records` carries both.
+//
+// THE CURRENT SPAN IS ITS OWN STORAGE rather than a field on the request scope: a span nests inside
+// a request, and `trace.headers` read inside a `trace.span` body has to name that span as the parent
+// (24.5) while a sibling running concurrently names its own.
+
+import { AsyncLocalStorage } from 'node:async_hooks' // bun implements AsyncLocalStorage and has no context-carrying api of its own
+import { writeSpan } from '#shared/log.ts'
+import { randomToken } from './randomToken.ts'
+import {
+    currentRequestScope,
+    type RequestScope,
+    timed,
+} from './requestScope.ts'
+
+const SPAN = new AsyncLocalStorage<string>()
+
+// 24.7 — RFC 9110's `token`, which is all a `server-timing` metric name may be.
+const TOKEN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/
+
+const TRACEPARENT = /^00-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})$/
+
+/**
+ * A random nonzero hex id of `bytes` bytes.
+ *
+ * A ZERO id is invalid in the format, so the vanishingly unlikely one is minted again.
+ */
+function hex(bytes: number): string {
+    for (;;) {
+        const minted = randomToken(bytes, 'hex')
+        if (!/^0+$/.test(minted)) return minted
+    }
+}
+
+/**
+ * The request's trace: its id, this process's span and the flags.
+ *
+ * 24.1 — BUILT ON FIRST ASK, and held on the scope for the rest of the request. The caller's trace
+ * id is adopted where a valid `traceparent` came in; this process's own span is minted either way.
+ */
+function traceOf(scope: RequestScope): NonNullable<RequestScope['trace']> {
+    if (scope.trace !== undefined) return scope.trace
+    const given = TRACEPARENT.exec(
+        scope.request?.headers.get('traceparent') ?? '',
+    )
+    scope.trace =
+        given === null || /^0+$/.test(given[1] as string)
+            ? { id: hex(16), span: hex(8), flags: '00' }
+            : {
+                  id: given[1] as string,
+                  span: hex(8),
+                  flags: given[3] as string,
+              }
+    return scope.trace
+}
+
+function currentSpan(scope: RequestScope): string {
+    return SPAN.getStore() ?? traceOf(scope).span
+}
+
+/**
+ * The current request's trace id, with `sampled`, `span` and `headers` on it.
+ *
+ * `''` OUTSIDE EVERY SCOPE: there is no operation for the work to belong to.
+ */
+export const trace = Object.assign(
+    (): string => {
+        const scope = currentRequestScope()
+        return scope === undefined ? '' : traceOf(scope).id
+    },
+    {
+        /**
+         * Whether the trace is sampled.
+         *
+         * 24.2 — the caller's flag, verbatim; a trace this process started samples nothing.
+         */
+        sampled(): boolean {
+            const scope = currentRequestScope()
+            return (
+                scope !== undefined &&
+                (Number.parseInt(traceOf(scope).flags, 16) & 1) === 1
+            )
+        },
+        /**
+         * Runs `body` as a span, logging it when it settles; returns what `body` returns.
+         *
+         * 24.3, 24.4 — ONE LINE PER SPAN, written when the body settles: `time` is when it started,
+         * and the duration is `performance.now`'s, which a clock change cannot move. 24.6 — and
+         * one `server-timing` entry where asked for, which only a span closed before the head
+         * went out reaches.
+         */
+        span<T>(
+            name: string,
+            body: () => T,
+            options?: { timing?: boolean },
+        ): T {
+            const timing = options?.timing === true
+            if (timing && !TOKEN.test(name))
+                throw new Error(
+                    `abide: trace.span("${name}", …, { timing: true }) names a server-timing metric, which must be an HTTP token — no spaces, quotes or separators. RULEBOOK 24.7.`,
+                )
+            const scope = currentRequestScope()
+            if (scope === undefined) return body()
+            traceOf(scope)
+            const startedAt = new Date().toISOString()
+            const started = performance.now()
+            const close = (): void => {
+                const duration = performance.now() - started
+                writeSpan(startedAt, `${name} ${duration.toFixed(3)}ms`)
+                if (timing) timed(scope.timing, name, duration)
+            }
+            let result: T
+            try {
+                result = SPAN.run(hex(8), body)
+            } catch (thrown) {
+                close()
+                throw thrown
+            }
+            if (result instanceof Promise) return result.finally(close) as T
+            close()
+            return result
+        },
+        /**
+         * The `traceparent` header naming the current span, for an outgoing call.
+         *
+         * 24.5.
+         */
+        headers(): Record<string, string> {
+            const scope = currentRequestScope()
+            if (scope === undefined) return {}
+            const current = traceOf(scope)
+            return {
+                traceparent: `00-${current.id}-${currentSpan(scope)}-${current.flags}`,
+            }
+        },
+    },
+)
+
+/**
+ * The answer's `traceresponse` value, naming this process's own span for the request.
+ *
+ * 21.2.
+ */
+export function traceResponse(): string | undefined {
+    const scope = currentRequestScope()
+    if (scope === undefined) return undefined
+    const current = traceOf(scope)
+    return `00-${current.id}-${current.span}-${current.flags}`
+}

package/src/server/versionOf.ts

@@ -0,0 +1,109 @@
+// 18.7 — THE VERSION A VALUE'S STANDING PRODUCTION IS NAMED BY OVER THE WIRE. Stamped where it is
+// asked for rather than where a production is minted, so a value no browser follows pays nothing on
+// its production path. A production is told apart from the one before by the ordinal, what is held
+// (6.10 moves no ordinal for `undefined`) and the patch epoch of what is held (5.7 moves no ordinal
+// for a patch).
+//
+// ONE COUNTER FOR THE PROCESS, started at the boot time in microseconds, so no two productions share
+// a number: not two values, not an entry evicted and built again, and not this process and the one
+// before it, which would have had to mint over a thousand a millisecond for its whole life to reach
+// where this one starts.
+//
+// 18.11 — A VERSION ONLY PATCHES MOVED TO keeps what they wrote, and the versions they were written
+// over, back through the last `RECENT_PATCHES` of them, so a follower standing anywhere on that chain
+// is sent the writes since rather than the value — a reconnect a few lines behind a log, or a burst a
+// slow tab missed. A production that was not a patch breaks the chain.
+
+import { servedCellOf } from '#shared/reactive/index.ts'
+import { PATCH_SINKS, type PatchOp } from '#shared/reactive/PATCH_SINKS.ts'
+import { PATCHES } from '#shared/reactive/PATCHES.ts'
+
+let next = Date.now() * 1000
+
+// How many patch steps back a follower can still be sent writes from. Trimmed in bulk at twice this,
+// so a write appends rather than shifting the chain.
+const RECENT_PATCHES = 64
+
+/** One patch's step along the chain: the version it was written over, and what it wrote. */
+type Step = { from: number; ops: PatchOp[] }
+
+type Stamp = {
+    ordinal: number
+    held: unknown
+    patched: number
+    version: number
+    // The patch steps that led to this version, oldest first — empty where a production broke them.
+    recent: Step[]
+}
+
+const STAMPS = new WeakMap<object, Stamp>()
+
+/** The version a value's standing production is named by over the wire. 18.7. */
+export function versionOf(value: unknown): number {
+    const cell = servedCellOf(value)
+    const held = (value as { peek(): unknown }).peek()
+    const patched =
+        held !== null && typeof held === 'object'
+            ? (PATCHES.written.get(held) ?? 0)
+            : 0
+    const stamp = STAMPS.get(cell)
+    if (
+        stamp !== undefined &&
+        stamp.ordinal === cell.ordinal &&
+        stamp.held === held &&
+        stamp.patched === patched
+    )
+        return stamp.version
+    // THE WRITES SINCE THE LAST STAMP stand for the change only where nothing else moved it.
+    const sink = PATCH_SINKS.get(cell)
+    const onlyPatched =
+        stamp !== undefined &&
+        stamp.ordinal === cell.ordinal &&
+        stamp.held === held
+    const ops =
+        onlyPatched && sink !== undefined && !sink.lost && sink.ops.length > 0
+            ? sink.ops
+            : null
+    if (sink !== undefined) {
+        sink.ops = []
+        sink.lost = false
+    }
+    next += 1
+    // The chain carries on from the stamp this replaces, whose array it takes over.
+    const recent = ops === null || stamp === undefined ? [] : stamp.recent
+    if (ops !== null && stamp !== undefined) {
+        recent.push({ from: stamp.version, ops })
+        if (recent.length >= RECENT_PATCHES * 2)
+            recent.splice(0, recent.length - RECENT_PATCHES)
+    }
+    STAMPS.set(cell, {
+        ordinal: cell.ordinal,
+        held,
+        patched,
+        version: next,
+        recent,
+    })
+    return next
+}
+
+/**
+ * Every patch written since version `since`, in order, or `undefined` where its follower must be sent
+ * the value: `since` older than the chain reaches, or not on it at all.
+ */
+export function patchesSince(
+    value: unknown,
+    since: number | undefined,
+): PatchOp[] | undefined {
+    if (since === undefined) return undefined
+    const recent = STAMPS.get(servedCellOf(value))?.recent
+    if (recent === undefined) return undefined
+    for (let at = 0; at < recent.length; at += 1) {
+        if ((recent[at] as Step).from !== since) continue
+        if (at === recent.length - 1) return (recent[at] as Step).ops
+        const ops: PatchOp[] = []
+        for (let step = at; step < recent.length; step += 1)
+            for (const op of (recent[step] as Step).ops) ops.push(op)
+        return ops
+    }
+    return undefined
+}

package/src/server/withoutTrailingSlash.ts

@@ -0,0 +1,4 @@
+/** `text` with every `/` it ends in taken off — a URL or a mount path, written the way it joins. */
+export function withoutTrailingSlash(text: string): string {
+    return text.replace(/\/+$/, '')
+}

package/src/shared/ADDRESSES.ts

@@ -0,0 +1,69 @@
+// EVERY ADDRESS THE FRAMEWORK ANSWERS AT, named once for the sides that have to agree about them:
+// the build writes them into the browser's bundle, the server answers them, the compiler files
+// handlers under them, and a browser dials them. A leaf, with no imports of its own, for the
+// reason every constant crossing a seam is one — a string spelled out on two sides is a request
+// that silently reaches nothing.
+
+/**
+ * The namespace every framework address lives under.
+ *
+ * UNDER `/__abide`, which is the namespace the framework's own addresses live in (19.1, 20.5,
+ * 25.1). That is what makes a route table and an asset table incapable of colliding: a page is a
+ * directory under `pages/` and no directory there can be named `__abide` without an author
+ * writing it, so nothing has to be checked at build time and nothing can be shadowed at run time.
+ * 38.21 is the clause.
+ */
+export const ABIDE_ADDRESS = '/__abide'
+
+/**
+ * Where the browser bundle is served.
+ *
+ * The bundle's own address below `ABIDE_ADDRESS` (38.17, 38.21). One request path answers
+ * everything under `ABIDE_ADDRESS` and the command supplying the app decides what is there, so a
+ * command with a second address of its own — the reload client `abide dev` serves (38.18) — adds
+ * one rather than a lane.
+ */
+export const CLIENT_ADDRESS = `${ABIDE_ADDRESS}/client`
+
+// 20.5, 20.9, 36.7 — the generated surfaces, which the CLI reaches as well as the server answers.
+
+/** The generated OpenAPI document. */
+export const OPENAPI_ADDRESS = `${ABIDE_ADDRESS}/openapi.json`
+/** The MCP endpoint. */
+export const MCP_ADDRESS = `${ABIDE_ADDRESS}/mcp`
+/** The stream of log records. */
+export const LOGS_ADDRESS = `${ABIDE_ADDRESS}/logs`
+/** The health check. */
+export const HEALTH_ADDRESS = `${ABIDE_ADDRESS}/health`
+/** Where a visitor's Claude Code bridge pairs, and is relayed turns (45.13). */
+export const BRIDGE_ADDRESS = `${ABIDE_ADDRESS}/bridge`
+
+/**
+ * The socket the dev reload client holds open.
+ *
+ * 38.18 — the LISTENER upgrades it on the main thread and the dev WORKER serves the script that
+ * opens it.
+ */
+export const DEV_ADDRESS = `${ABIDE_ADDRESS}/dev`
+
+/**
+ * Where a `server/rpc` handler is answered over http.
+ *
+ * 16.2 — its path below that directory, then its export name (19.1). The build writes the address
+ * into the browser's wrapper and the server answers at it.
+ */
+export const RPC_ADDRESS = `${ABIDE_ADDRESS}/rpc`
+
+/**
+ * Where the one web socket a page follows its `GET`s over is served, below the app's root.
+ *
+ * 18.1 — the server answers the upgrade there, and a browser's mux dials it.
+ */
+export const SOCKET_ADDRESS = `${ABIDE_ADDRESS}/socket`
+
+/**
+ * Where a browser loads the principal document the server resolved from the sealed cookie.
+ *
+ * 26.2.
+ */
+export const PRINCIPAL_ADDRESS = `${ABIDE_ADDRESS}/principal`

package/src/shared/ANCHORS.ts

@@ -0,0 +1,54 @@
+// The comment anchors — the ONE thing a compiled document carries that an authored one does not,
+// spelled two ways: a dynamic region's pair, and a text run's pair while it holds a `Raw` value
+// (32.30), kept apart from the region's by 32.31. The server and the compiler write them through
+// `anchorMarkup.ts`, and `markupRun` spells its own because it runs in the browser too; the client
+// reads them as comment data.
+//
+// WHY ANYTHING AT ALL, when a static region needs nothing: a region's content length depends on a
+// value, so every sibling after it moves. Child-index addressing cannot survive that, and the
+// anchors are what the siblings after a region are counted from instead.
+//
+// WHY A COMMENT. `invariance.spec.ts` measures it: a comment is not an element, so it joins no
+// combinator chain and changes nothing about descendant, `:has`, `+`, `~`, `:nth-child` or
+// `:empty` matching. A wrapper element breaks all of those; an attribute is matched by a selector
+// the author wrote. A comment is the only structure a compiler may add, and it adds one for each
+// pair here, for the same reason: markup whose length depends on a value.
+//
+// 41.24 — A REGION THE SERVER PAINTED AN ARM OF CARRIES THE ARM after the open (`armAnchor.ts`).
+// Only the server writes it: a region the browser fills is adopted in the same turn its arm was
+// chosen, so the two cannot disagree. Every comment whose data starts with `REGION_OPEN` opens a
+// region, a named one included (`opensRegion`).
+export const REGION_OPEN = '['
+export const REGION_CLOSE = ']'
+
+/**
+ * A row's opening anchor, emitted only where a row's body has more than one top-level node.
+ *
+ * A single-element row IS its element — the nodes between the region's anchors are the rows and
+ * nothing has to be added to tell them apart — but `<dt>{k}</dt><dd>{v}</dd>` has no such node,
+ * and counting elements there finds four rows in a list of two.
+ *
+ * One comment per ROW, not per slot, which is the difference between ~2.5 bytes gzipped a row and
+ * the doubled page `benchGrid.ts` measured for per-slot markers.
+ */
+export const ROW_OPEN = 'r'
+
+/**
+ * The comment anchor opening a text run while it holds markup.
+ *
+ * 32.30 — the comment anchors a text run is delimited by WHILE IT HOLDS MARKUP (32.26), and
+ * nothing else in a document carries them. A run is one text node while its value is text; a
+ * `Raw` part parses into any number of nodes, so every sibling after it is found from the closing
+ * anchor instead — the way a region's siblings are found from `REGION_CLOSE`.
+ *
+ * 32.31 — NOT THE REGION PAIR. A blank run the server rendered as nothing stands where the next
+ * region's `REGION_OPEN` is, so a run that read a region's anchor as its own would take the
+ * region's content for its markup. And a run's anchors never nest: what stands between them is the
+ * author's markup.
+ *
+ * ONLY WHILE A PART IS `Raw`, so a run holding text — every slot whose value was never branded —
+ * is one text node and costs nothing in the document.
+ */
+export const RAW_OPEN = '{'
+/** The comment anchor closing a text run while it holds markup; see `RAW_OPEN`. */
+export const RAW_CLOSE = '}'