@abide/abide 0.57.1 → 0.100.0

package/src/compiler/tokenize.ts

@@ -0,0 +1,317 @@
+import { SyntaxKind } from 'typescript/unstable/ast'
+import { createScanner, type Scanner } from 'typescript/unstable/ast/scanner'
+
+// ONE TOKENIZER, read by `splitImports`, `forBlock`, `projectShadow` and `Lowering`, and by
+// `parseAbide` through `slotEnd`, which is the same scan. A template literal's re-scan, the
+// regex-or-division question and where a slot ends are each answered once, so every reader agrees
+// by construction rather than case by case.
+//
+// A SCANNER SAYS WHERE THE TOKENS ARE, NOT WHAT THEY MEAN, and that is the whole contract — the
+// expression grammar is never parsed, which is what keeps 19.11 a property of the file.
+
+export type Token = {
+    kind: SyntaxKind
+    text: string
+    start: number
+    end: number
+}
+
+/** The tokens of `source`, scanned the way `slotEnd` scans a slot. */
+export function tokenize(source: string): Token[] {
+    const tokens: Token[] = []
+    scan(source, 0, (kind, scanner) => {
+        tokens.push({
+            kind,
+            text: scanner.getTokenText(),
+            start: scanner.getTokenStart(),
+            end: scanner.getTokenEnd(),
+        })
+        return true
+    })
+    return tokens
+}
+
+/**
+ * How far `kind` moves the bracket depth a top-level separator is found at: a template's
+ * substitutions nest as a call's arguments do, so `${a, b}` holds its comma.
+ */
+export function nesting(kind: SyntaxKind): number {
+    switch (kind) {
+        case SyntaxKind.OpenParenToken:
+        case SyntaxKind.OpenBracketToken:
+        case SyntaxKind.OpenBraceToken:
+        case SyntaxKind.TemplateHead:
+            return 1
+        case SyntaxKind.CloseParenToken:
+        case SyntaxKind.CloseBracketToken:
+        case SyntaxKind.CloseBraceToken:
+        case SyntaxKind.TemplateTail:
+            return -1
+        default:
+            return 0
+    }
+}
+
+/**
+ * The index of the `}` closing the template slot opened at `open`, or the source's length.
+ *
+ * 32.1 — the same scan `tokenize` makes, so the regex-or-division
+ * question, a template literal's substitutions, strings and comments are answered once for both
+ * — `{f('}')}`, `{ /* } *\/ x }` and `{xs.filter(s => /}/.test(s))}` end where they read as ending.
+ *
+ * A CLOSE DIRECTIVE IS THE ONE PLACE THE TEMPLATE'S GRAMMAR OVERRIDES JAVASCRIPT'S. `{/if}`,
+ * `{/for}`, `{/try}` — any `/name`, with any whitespace around it — read as a regular expression
+ * would run on to the next `/` and take the markup after the block with them. No expression is a
+ * bare `/name` either, so the whole shape is the directive rather than a list of block names.
+ *
+ * AN OPEN DIRECTIVE'S NAME IS SKIPPED, and the scan starts past it expecting an operand:
+ * `{#if /'/.test(s)}` opens a literal, where `#if` read as a private name would divide.
+ */
+export function slotEnd(source: string, open: number): number {
+    let first = open + 1
+    while (first < source.length && isSpace(source[first] as string)) first += 1
+    if (source[first] === '/') {
+        let close = first + 1
+        while (close < source.length && isLetter(source[close] as string))
+            close += 1
+        if (close > first + 1) {
+            while (close < source.length && isSpace(source[close] as string))
+                close += 1
+            if (source[close] === '}') return close
+        }
+    }
+    let from = open
+    let depth = 0
+    if (source[first] === '#') {
+        let name = first + 1
+        while (name < source.length && isLetter(source[name] as string))
+            name += 1
+        if (name > first + 1) {
+            from = name
+            depth = 1
+        }
+    }
+    let end = source.length
+    scan(source, from, (kind, scanner) => {
+        if (kind === SyntaxKind.OpenBraceToken) depth += 1
+        else if (kind === SyntaxKind.CloseBraceToken) {
+            depth -= 1
+            if (depth === 0) {
+                end = scanner.getTokenStart()
+                return false
+            }
+        }
+        return true
+    })
+    return end
+}
+
+// A `/` IS A REGEX OR A DIVISION AND THE SCANNER CANNOT TELL, so it answers `SlashToken` and the
+// scan decides: a literal where an OPERAND IS EXPECTED, a division where one just ended. One token
+// of lookback cannot say which after a closer — `(a) / b` divides and `if (x) /re/` does not — so
+// each opener is tagged, when it is read, with what its closer hands back: the tokenizer-context
+// approach acorn and sweet.js take, which reads brackets and never the expression grammar.
+const OPERAND = 0 // `)` `]` and an object literal's `}` end a value
+const STATEMENT = 1 // `)` of `if`/`while`/`for`/`with` and a block's `}` are followed by a statement
+const SUBSTITUTION = 2 // `${`, whose `}` continues the template literal
+
+/**
+ * The tokens after which a `{` opens a body rather than an object literal.
+ *
+ * A `{` AFTER ONE OF THESE OPENS A BODY even though an operand could stand there — an object
+ * literal only follows a token that takes a value. `>` and `void` end a TypeScript return type:
+ * `f(): Promise<T> {` and `f(): void {`. What this misses is a `case x: {` block, read as a
+ * literal because `:` also precedes an object's value, so a regex opening the statement after
+ * that block scans as a division.
+ */
+const BODY_AFTER = new Set<SyntaxKind | undefined>([
+    undefined,
+    SyntaxKind.SemicolonToken,
+    SyntaxKind.CloseParenToken,
+    SyntaxKind.OpenBraceToken,
+    SyntaxKind.CloseBraceToken,
+    SyntaxKind.EqualsGreaterThanToken,
+    SyntaxKind.GreaterThanToken,
+    SyntaxKind.VoidKeyword,
+    SyntaxKind.ElseKeyword,
+    SyntaxKind.DoKeyword,
+    SyntaxKind.TryKeyword,
+    SyntaxKind.CatchKeyword,
+    SyntaxKind.FinallyKeyword,
+])
+
+/**
+ * The one scanner `scan` resets per call.
+ *
+ * ONE SCANNER, reset per call: a scanner is an object of ~50 closures, and `slotEnd` asks once per
+ * `{` in a template. Safe because no `visit` scans again before its own scan returns.
+ */
+const SCANNER = createScanner(true)
+
+/**
+ * THE SCAN BOTH READERS SHARE, from `from`, handing each token to `visit` until it answers false.
+ */
+function scan(
+    source: string,
+    from: number,
+    visit: (kind: SyntaxKind, scanner: Scanner) => boolean,
+): void {
+    const scanner = SCANNER
+    scanner.setText(source, from)
+    // A TEMPLATE LITERAL IS NOT ORDINARY TOKENS. `` `a${b}c` `` scans as TemplateHead, then `b`,
+    // then a CLOSE BRACE that has to be RE-SCANNED as the literal's continuation — without that
+    // the scanner reads `c\`` as ordinary code, and a bare word in the TEXT of a template gets
+    // rewritten as if it were a read: `${owner} — … of notes` would lower to
+    // `${owner())} — … of notes()`, which is not a program.
+    //
+    // Only a `}` whose opener was the `${` continues the literal, so an object literal in a
+    // substitution closes on its own brace.
+    const openers: number[] = []
+    let previous: SyntaxKind | undefined
+    let expectsOperand = true
+    while (true) {
+        let kind = scanner.scan()
+        if (kind === SyntaxKind.EndOfFile) return
+        if (
+            expectsOperand &&
+            (kind === SyntaxKind.SlashToken ||
+                kind === SyntaxKind.SlashEqualsToken)
+        )
+            kind = scanner.reScanSlashToken()
+        else if (
+            kind === SyntaxKind.CloseBraceToken &&
+            openers[openers.length - 1] === SUBSTITUTION
+        )
+            kind = scanner.reScanTemplateToken(false)
+        // A KEYWORD AFTER A `.` IS A MEMBER NAME — `row.type / 2`, `obj.in / 2`, `x.if(a) / 2`.
+        const read =
+            (previous === SyntaxKind.DotToken ||
+                previous === SyntaxKind.QuestionDotToken) &&
+            kind >= SyntaxKind.FirstKeyword &&
+            kind <= SyntaxKind.LastKeyword
+                ? SyntaxKind.Identifier
+                : kind
+        switch (read) {
+            case SyntaxKind.OpenParenToken:
+                openers.push(
+                    previous === SyntaxKind.IfKeyword ||
+                        previous === SyntaxKind.WhileKeyword ||
+                        previous === SyntaxKind.ForKeyword ||
+                        previous === SyntaxKind.WithKeyword
+                        ? STATEMENT
+                        : OPERAND,
+                )
+                expectsOperand = true
+                break
+            case SyntaxKind.OpenBraceToken:
+                openers.push(
+                    !expectsOperand || BODY_AFTER.has(previous)
+                        ? STATEMENT
+                        : OPERAND,
+                )
+                expectsOperand = true
+                break
+            case SyntaxKind.OpenBracketToken:
+                openers.push(OPERAND)
+                expectsOperand = true
+                break
+            case SyntaxKind.TemplateHead:
+                openers.push(SUBSTITUTION)
+                expectsOperand = true
+                break
+            case SyntaxKind.CloseParenToken:
+            case SyntaxKind.CloseBraceToken:
+            case SyntaxKind.CloseBracketToken:
+            case SyntaxKind.TemplateTail:
+                expectsOperand = openers.pop() === STATEMENT
+                break
+            // PREFIX OR POSTFIX, THESE LEAVE THE QUESTION WHERE IT WAS: a prefix `!` stands where an
+            // operand was expected and one still is, a postfix `x!` or `x++` follows one and ends it.
+            case SyntaxKind.ExclamationToken:
+            case SyntaxKind.PlusPlusToken:
+            case SyntaxKind.MinusMinusToken:
+                break
+            default:
+                expectsOperand = !endsOperand(read)
+        }
+        previous = read
+        if (!visit(kind, scanner)) return
+    }
+}
+
+/**
+ * Whether `kind` is a contextual keyword, which is a legal binding name.
+ *
+ * The scanner answers `GetKeyword` for `get` and `TypeKeyword` for `type` wherever they stand.
+ */
+export function isContextualKeyword(kind: SyntaxKind): boolean {
+    return (
+        kind >= SyntaxKind.FirstContextualKeyword &&
+        kind <= SyntaxKind.LastContextualKeyword
+    )
+}
+
+/**
+ * A NAME, A LITERAL OR A VALUE KEYWORD ENDS AN OPERAND, so a `/` after it divides. A contextual
+ * keyword is a name — `type / 2`, `get / 2` — except the two that take an operand after them,
+ * `await` and `of`, after which a `/` opens a literal.
+ */
+function endsOperand(kind: SyntaxKind): boolean {
+    if (
+        kind >= SyntaxKind.FirstLiteralToken &&
+        kind <= SyntaxKind.LastLiteralToken
+    )
+        return true
+    if (isContextualKeyword(kind))
+        return kind !== SyntaxKind.AwaitKeyword && kind !== SyntaxKind.OfKeyword
+    return (
+        kind === SyntaxKind.Identifier ||
+        kind === SyntaxKind.PrivateIdentifier ||
+        kind === SyntaxKind.ThisKeyword ||
+        kind === SyntaxKind.SuperKeyword ||
+        kind === SyntaxKind.TrueKeyword ||
+        kind === SyntaxKind.FalseKeyword ||
+        kind === SyntaxKind.NullKeyword
+    )
+}
+
+/**
+ * Whether `char` is HTML's ASCII whitespace.
+ *
+ * HTML's ASCII WHITESPACE — every position this is asked about is template grammar, not
+ * JavaScript's, and `\s` answers yes to a no-break space the HTML tokenizer keeps as text.
+ */
+export function isSpace(char: string): boolean {
+    return (
+        char === ' ' ||
+        char === '\t' ||
+        char === '\n' ||
+        char === '\f' ||
+        char === '\r'
+    )
+}
+
+/**
+ * The index just past the CSS string opening at `open`.
+ *
+ * A `;` or a `:` inside one is the value's own.
+ */
+export function skipQuoted(source: string, open: number): number {
+    const quote = source[open]
+    let at = open + 1
+    while (at < source.length) {
+        const char = source[at]
+        if (char === '\\') {
+            at += 2
+            continue
+        }
+        if (char === quote) return at + 1
+        at += 1
+    }
+    return at
+}
+
+/** A block name is lower-case ASCII. */
+function isLetter(char: string): boolean {
+    return char >= 'a' && char <= 'z'
+}

package/src/compiler/trackingWarnings.ts

@@ -0,0 +1,279 @@
+import { type Node, SyntaxKind } from 'typescript/unstable/ast'
+import {
+    isArrowFunction,
+    isAwaitExpression,
+    isBinaryExpression,
+    isCallExpression,
+    isConditionalExpression,
+    isDoStatement,
+    isForOfStatement,
+    isForStatement,
+    isFunctionExpression,
+    isIdentifier,
+    isIfStatement,
+    isPropertyAccessExpression,
+    isWhileStatement,
+} from 'typescript/unstable/ast/is'
+import { FUNCTIONS, TRANSPARENT } from './classifyRead.ts'
+import type { Finding } from './Finding.ts'
+import type { PositionKind, PositionTable } from './PositionTable.ts'
+
+// 14.14, 14.15, 14.16 — WHERE A READ STANDS IN A BODY THAT TRACKS, and the three ways it can stand
+// there and not do what it looks like doing. Read off the checker's own tree of the projection, so a
+// position here is a projection offset. Each is a warning rather than a refusal: the program is
+// valid, and a read that is not tracked is sometimes what was meant.
+//
+// A TRACKED BODY is an unkeyed `reactive` body (14.3), a `watch` effect (14.6), or a template
+// position (14.2) of a kind in `TRACKED`.
+
+// A callback these hand a function to runs it before they return, so a read inside it is the
+// body's own read. Anything else — `then`, `setTimeout`, an event, a function kept for later — may
+// run after the body has returned, when nothing is tracking.
+const SYNCHRONOUS = new Set([
+    'map',
+    'filter',
+    'reduce',
+    'reduceRight',
+    'forEach',
+    'some',
+    'every',
+    'find',
+    'findIndex',
+    'findLast',
+    'findLastIndex',
+    'flatMap',
+    'sort',
+    'toSorted',
+    'replace',
+    'replaceAll',
+    'from',
+])
+
+type Body = { node: Node; kind: 'reactive' | 'watch' | 'template' }
+
+/**
+ * 14.2 — the template positions that track: what the template renders, tests or iterates, and what
+ * a component is handed, which the child reads where it tracks. Not a listener or an element's
+ * `bind:` (14.9), a branch-local `<script>` (14.8), an inline component's head (14.7), or a value
+ * the shadow types as `any`.
+ */
+const TRACKED: ReadonlySet<PositionKind> = new Set([
+    'slot',
+    'attribute',
+    'condition',
+    'subject',
+    'key',
+    'prop',
+    'componentBind',
+    'tag',
+])
+
+/** `node` past any `TRANSPARENT` wrapper around it, and what holds it. */
+function holderOf(node: Node): { child: Node; parent: Node } {
+    let child = node
+    while (TRANSPARENT.has(child.parent.kind)) child = child.parent
+    return { child, parent: child.parent }
+}
+
+/** The name a call's callee spells — `f` in `f()` and in `x.f()` — or `undefined`. */
+function calleeName(call: Node): string | undefined {
+    if (!isCallExpression(call)) return undefined
+    const callee = call.expression
+    if (isIdentifier(callee)) return callee.text
+    if (isPropertyAccessExpression(callee) && isIdentifier(callee.name))
+        return callee.name.text
+    return undefined
+}
+
+/** Which kind of tracked body a function is, or `undefined` where it is none. */
+function trackedKind(functionNode: Node): Body['kind'] | undefined {
+    if (!isArrowFunction(functionNode) && !isFunctionExpression(functionNode))
+        return undefined
+    const { child, parent } = holderOf(functionNode)
+    if (!isCallExpression(parent) || parent.arguments[0] !== child)
+        return undefined
+    const name = calleeName(parent)
+    // 14.4 — a body declaring a parameter is keyed, and does not track.
+    if (name === 'reactive' && functionNode.parameters.length === 0)
+        return 'reactive'
+    if (name === 'watch') return 'watch'
+    return undefined
+}
+
+/** Whether a function a tracked body creates runs before the body returns. */
+function runsSynchronously(
+    functionNode: Node,
+    positions: PositionTable,
+): boolean {
+    const { child, parent } = holderOf(functionNode)
+    // 14.18 — A COMPONENT'S `bind:` PAIR (32.6) is not kept for later: the child calls `get` inside a body
+    // that tracks, and `set` where it writes, so a read in either is where it should be.
+    const member =
+        parent.kind === SyntaxKind.PropertyAssignment ? parent : child
+    if (
+        member.parent.kind === SyntaxKind.ObjectLiteralExpression &&
+        positions.of(holderOf(member.parent).child)?.kind === 'componentBind'
+    )
+        return true
+    if (!isCallExpression(parent)) return false
+    if (parent.expression === child) return true
+    const name = calleeName(parent)
+    return name !== undefined && SYNCHRONOUS.has(name)
+}
+
+/** Whether `child` is the condition of `parent`, which decides what else runs. */
+function isCondition(child: Node, parent: Node): boolean {
+    if (
+        isIfStatement(parent) ||
+        isWhileStatement(parent) ||
+        isDoStatement(parent)
+    )
+        return parent.expression === child
+    if (isConditionalExpression(parent)) return parent.condition === child
+    if (isForStatement(parent)) return parent.condition === child
+    if (isBinaryExpression(parent)) {
+        const operator = parent.operatorToken.kind
+        return (
+            parent.left === child &&
+            (operator === SyntaxKind.AmpersandAmpersandToken ||
+                operator === SyntaxKind.BarBarToken ||
+                operator === SyntaxKind.QuestionQuestionToken)
+        )
+    }
+    return false
+}
+
+// Every `await` a body runs itself, a nested function's aside. Asked once per body.
+const AWAITS = new WeakMap<Node, number[]>()
+
+/**
+ * Where each `await` a body runs itself suspends, memoized in `AWAITS`.
+ *
+ * AT THE END OF WHAT IT AWAITS, not at the keyword: the operand is evaluated before the body
+ * suspends, so `id` in `await call({ id })` is read while the body still tracks — where `c` in
+ * `await a(b) + c` is not. A `for await` suspends once its iterable is evaluated.
+ */
+function awaitsIn(body: Node): number[] {
+    let found = AWAITS.get(body)
+    if (found !== undefined) return found
+    found = []
+    const list = found
+    const visit = (node: Node): void => {
+        if (node !== body && FUNCTIONS.has(node.kind)) return
+        if (isAwaitExpression(node)) list.push(node.expression.end)
+        if (isForOfStatement(node) && node.awaitModifier !== undefined)
+            list.push(node.expression.end)
+        node.forEachChild((child) => {
+            visit(child)
+            return undefined
+        })
+    }
+    visit(body)
+    AWAITS.set(body, found)
+    return found
+}
+
+/**
+ * Why a read in a tracked body may not track: the 14.14, 14.15 and 14.16 warnings for one read.
+ *
+ * `reads` is every reactive read in the file: where it starts, and the name it reads.
+ */
+export function trackingWarnings(
+    read: Node,
+    name: string,
+    positions: PositionTable,
+    reads: readonly { start: number; name: string }[],
+): Finding[] {
+    const created: Node[] = []
+    let decides: { condition: Node; within: Node } | undefined
+    let body: Body | undefined
+    let child: Node = read
+    // THE TEMPLATE POSITION the read stands in, wherever the projection put it: an arm, a row and
+    // an inline component's body are projected inside the `if`, the `for` and the function they are.
+    for (let node = read.parent; node !== undefined; node = node.parent) {
+        const position = positions.of(child)
+        if (position !== undefined) {
+            if (TRACKED.has(position.kind))
+                body = { node: child, kind: 'template' }
+            break
+        }
+        if (
+            created.length === 0 &&
+            decides === undefined &&
+            isCondition(child, node)
+        )
+            decides = { condition: child, within: node }
+        if (FUNCTIONS.has(node.kind)) {
+            const kind = trackedKind(node)
+            if (kind !== undefined) {
+                body = { node, kind }
+                break
+            }
+            created.push(node)
+        }
+        child = node
+    }
+    if (body === undefined) return []
+    const warnings: Finding[] = []
+    const at = read.getStart()
+    // 14.16 — a function the body creates and hands to something that runs it later.
+    for (const functionNode of created)
+        if (!runsSynchronously(functionNode, positions)) {
+            warnings.push({
+                at,
+                message: `abide: \`${name}\` is read inside a function this tracked body creates and does not call as it runs, so nothing tracks the read and a change to \`${name}\` will not rerun the body. Read it in the body and close over the value. RULEBOOK 14.16.`,
+            })
+            return warnings
+        }
+    // 14.14 — past an `await`, the body has returned to whatever tracked it.
+    for (const suspends of awaitsIn(body.node))
+        if (suspends <= at) {
+            warnings.push({
+                at,
+                message: `abide: \`${name}\` is read after an \`await\` in a tracked body, and tracking ends at the first \`await\`, so a change to \`${name}\` will not rerun the body. Read it before the \`await\`. RULEBOOK 14.14.`,
+            })
+            break
+        }
+    // 14.15 — what a condition decides is which other values the body reads, so they differ run
+    // to run and each run re-subscribes them.
+    if (
+        decides !== undefined &&
+        body.kind === 'reactive' &&
+        decidesARead(decides.condition, decides.within, name, reads)
+    )
+        warnings.push({
+            at,
+            message: `abide: \`${name}\` decides a condition in a reactive body, so which values the body reads changes from run to run, and every change re-subscribes them. Read what both branches need before deciding. RULEBOOK 14.15.`,
+        })
+    return warnings
+}
+
+/**
+ * Whether a read of ANOTHER value stands in what the condition decides.
+ *
+ * What it decides is the rest of the statement or expression it conditions — which is the only
+ * case where the body's sources can change. The condition's own value read again in a branch is
+ * read on every run either way.
+ */
+function decidesARead(
+    condition: Node,
+    within: Node,
+    name: string,
+    reads: readonly { start: number; name: string }[],
+): boolean {
+    const from = within.getStart()
+    const to = within.end
+    const skipFrom = condition.getStart()
+    const skipTo = condition.end
+    for (const read of reads) {
+        const at = read.start
+        if (
+            read.name !== name &&
+            at >= from &&
+            at < to &&
+            (at < skipFrom || at >= skipTo)
+        )
+            return true
+    }
+    return false
+}

package/src/compiler/writeDefaultProject.ts

@@ -0,0 +1,42 @@
+// 38.31 — AN APP WITH NO tsconfig.json IS TYPED AGAINST ONE OF ABIDE'S, not read untyped. The checker
+// is what tells the compiler which names are `Reactive`s (31.3), and with no project to ask every
+// template position read as static: the server painted an unlanded read by throwing out of the
+// render (41.4), the client never bound a slot at all, and `props` went unseen — an app that built
+// clean and did nothing. So the absence of a project gets a project rather than a second compiler.
+//
+// WRITTEN OUTSIDE THE APP. The build does not write into an author's source tree, so the file lives
+// in a temporary directory for as long as the session that reads it, and names the app's files by
+// absolute path.
+
+import { mkdtemp, rm } from 'node:fs/promises' // bun exposes no temporary-directory creation or recursive removal of its own
+import { tmpdir } from 'node:os' // bun exposes no temporary-directory path of its own
+
+/** What every abide app in the docs and the scaffold is written against. */
+export const COMPILER_OPTIONS = {
+    strict: true,
+    target: 'esnext',
+    module: 'preserve',
+    moduleResolution: 'bundler',
+    allowImportingTsExtensions: true,
+    noEmit: true,
+    skipLibCheck: true,
+}
+
+/** Writes a temporary tsconfig covering `root`, with the function that removes it. */
+export async function writeDefaultProject(
+    root: string,
+): Promise<{ tsconfig: string; remove: () => Promise<void> }> {
+    const directory = await mkdtemp(`${tmpdir()}/abide-project-`)
+    const tsconfig = `${directory}/tsconfig.json`
+    await Bun.write(
+        tsconfig,
+        JSON.stringify({
+            compilerOptions: COMPILER_OPTIONS,
+            include: [`${root}/**/*`],
+        }),
+    )
+    return {
+        tsconfig,
+        remove: () => rm(directory, { recursive: true, force: true }),
+    }
+}

package/src/server/BRIDGE_VERSION.ts

@@ -0,0 +1,3 @@
+// The `abide-bridge` release a pairing command names, so a visitor's `bunx` runs the relay this
+// server speaks. `packages/abide/tests/claudeCode.test.ts` holds it to the bridge package's own.
+export const BRIDGE_VERSION = '0.1.0'