@velarscript/cli 0.11.1 → 0.12.0

package/skill/ai-skill.md

@@ -1,16 +1,17 @@
-# The VelarScript AI skill brief
+# The VelarScript Core AI skill brief
 
 This is the language brief for AI agents working in a VelarScript project. It
-is agent-agnostic markdown, it ships inside the toolchain, and `velar skill`
+is agent-agnostic markdown, it ships inside the toolchain, and `velar skill core`
 prints it verbatim — no network, no external documentation. Every code fence
 in this file compiles against the current compiler; the brief cannot drift
-from the language.
+from the language. Projects using a framework also load the separate `web`,
+`node`, or `desktop` brief named by their `AGENTS.md`.
 
 ## What VelarScript is
 
-VelarScript (Vel) is an extensible programming language for the AI era where the
-framework is the language: `component`, `state`, and `look` are keywords rather
-than imports, so one checked language covers markup, styling, state, and tests.
+VelarScript (Vel) is an extensible programming language for the AI era. Core
+owns the general-purpose language; a framework extension may add checked
+syntax without changing Core's grammar or strings.
 You write the Vel and every later change; the owner reads the result; the
 compiler guards each change. Vel's parents are JavaScript and Python: ask the
 mother about behavior — the program runs inside her — and the father about spelling.
@@ -46,23 +47,21 @@ JavaScript global, so there are exactly four and the list is closed:
 `escapeHtml`, `codePoint`, `fromCodePoint`, `matches`, `findMatch`,
 `findMatches`, `replaceMatches`, `splitPattern`). A string method is a core
 operation; `Text.*` is the extension toolbox, and nothing moves between them.
-Web visual builders are named imports from `velar/look` — there is no `Look`
-global in JavaScript, so there is no `Look.` prefix here either. These names
-need no import and cannot be shadowed: `const Text = 1` is rejected. `print`,
+These names need no import and cannot be shadowed: `const Text = 1` is rejected. `print`,
 `str`, `number`, `equals`, and `range` are likewise in the Core prelude —
 `equals(a, b)` is the one content-comparison spelling. One roster grants and
 protects these names. Capabilities stay explicit imports. Durations use `ms` or
 `s`, so write `await Promise.sleep(250ms)`, not a bare number.
 
-Use checked binary/random/task, manifest Workers, pull WebSockets, Node SQLite,
-Web binary IndexedDB, and official adapters. A direct `for index in range(...):` is a native counter; range as a value is a List. Use `UInt16Buffer` for 16-bit numeric state,
+Use checked binary, random, task, and official adapter APIs. A direct
+`for index in range(...):` is a native counter; range as a value is a List. Use `UInt16Buffer` for 16-bit numeric state,
 `UInt8Buffer` for compact data, and bounded `UInt32Builder`/`Float32Builder` values for variable-size numeric output.
 
 ## Project setup
 
 A VelarScript project is a directory containing a `velar.json` manifest. Let
-the toolchain write it — `velar create my-app` scaffolds the Web template, and
-`--template node|desktop|docs|library|component` picks another. Each writes
+the toolchain write it — `velar create my-lib --template library` scaffolds a
+Core source library; other templates select their own framework brief. Each writes
 `velar.json`, a `package.json` whose scripts are the gates, a `src/` tree, a
 passing test, and an `AGENTS.md`.
 
@@ -70,7 +69,7 @@ Writing the manifest yourself: `formatVersion` is required, `extensions` may be
 omitted by a project that loads none, `entry` defaults to `src/main.vel`,
 `outDir` to `dist`, and `publicDir` to `public`.
 
-A Core project (CLI, library, Node) loads no extensions:
+A Core project (CLI or library) loads no extensions:
 
 ```json
 {
@@ -80,83 +79,14 @@ A Core project (CLI, library, Node) loads no extensions:
 }
 ```
 
-A Web project activates the Web extension **by package name**. That one line is
-what turns on `component`, JSX, `state`, `computed`, `resource`, `action`,
-`watch`, `look`, and `mount`; without it `component` is an unknown declaration
-keyword and every JSX token is a parse error:
-
-```json
-{
-  "formatVersion": 2,
-  "entry": "src/main.vel",
-  "extensions": ["@velarscript/web"]
-}
-```
-
-An extension owns its own manifest key — `"web": {"title": "My App"}` sets the
-document title. Anything else in `velar.json` is rejected by name.
-
-**Files the toolchain owns.** `dist/` is build output, and in a Web build the
-toolchain writes `dist/index.html` itself — the title comes from `web.title`, the
-favicon from `web.icon` (a `publicDir`-relative `.svg`/`.png`/`.ico` path; the
-build fails if no such file exists), the
-mount host is `<div id="app"></div>`, and assets are content-hashed. Never author
-that file; a `public/index.html` is overwritten by the generated one, while
-everything else in `public/` is copied through. `.velar/` is scratch; both belong in `.gitignore`.
+An extension owns its syntax, modules, and manifest keys. Anything outside the
+active owners' closed manifest vocabulary is rejected by name. `dist/` is build
+output and `.velar/` is scratch; both belong in `.gitignore`.
 
 **Tests.** `velar test` finds every `*.test.vel` file under the project (skipping
 `outDir` and `publicDir`) and runs its `test "name":` blocks. The name is a
 sentence about the code, quoted verbatim by the reporter and unique in its
 module; the body may `await` directly and needs no `export`. A file that declares no tests is a failure rather than a skip.
-`velar test --browser` runs `*.browser.test.vel` in a real browser — and bare
-`--browser` is **Chromium only**. Three engines is `--browser=all` (or
-`--browser all`), which is what any cross-browser claim costs;
-`--browser=firefox` and `--browser=webkit` pick one.
-
-**Separate the mounted entrypoint from testable code.** A test runs in Node with
-no DOM, so a headless test that imports the module calling `mount` fails on
-`document`. Keep the entry trivial and put everything worth testing in modules it
-imports:
-
-```velar fragment
-// src/main.vel — the mounted entrypoint; no test imports this file
-import {App} from "./app.vel"
-
-mount(<App />, "#app")
-```
-
-Components, functions, and types live in `src/app.vel` and its neighbours;
-`src/app.test.vel` tests those exports headlessly and
-`src/app.browser.test.vel` drives the mounted application.
-
-**A browser test drives the page; it does not build one.** Its body runs in the
-test process against a page already running the production build, so `mount`,
-JSX, and `document` are unavailable there — the driving surface is
-`velar/web-test`, and selectors are ordinary CSS:
-
-```velar fragment
-import {expect} from "velar/test"
-import {browser, localStorage} from "velar/web-test"
-
-test "adding a link shows it in the list":
-    await browser.open("/")
-    await browser.fill("#title", "Vel")
-    await browser.click("#add")
-    await browser.waitForText("[data-item]", "Vel")
-    expect(await browser.text("[data-count]")).toBe("1")
-    expect(await localStorage.get("reading")).toBe(`[{"title":"Vel"}]`)
-```
-
-`browser` also carries `reload`, `press`, `select`, `attribute`, `count`,
-`visible`, `waitFor`, `currentPath`, and `viewport`; `localStorage` and
-`sessionStorage` read and write the page's raw storage. Any unhandled error —
-in the page or in the test process — fails the test.
-
-`velar/web-test` may be imported **only** from a `*.browser.test.vel` module.
-Reaching for it from application code, from a plain `*.test.vel`, through
-`import js`, or through a re-export is rejected on the import line — rename the
-module or move the browser test into one of its own. Application code that
-needs the page reaches it through `velar/browser` instead.
 
 ## The traps your reflexes will hit
 
@@ -173,17 +103,17 @@ them; the first two are the **silent traps** in the list — read them twice.
 | `interface X:`, `record X:`, `struct X:` | `type X:` — one keyword for record shapes and aliases. |
 | `items.length` | `items.size` (also on strings, Sets, Maps). |
 | `items.push(x)` | `items.append(x)`. There is no `splice`/`shift`/`unshift`/mutating `sort`; use `insert`, `pop`, `remove`, `extend`, and the copying `sorted()`/`reversed()`. |
+| `const items = []`, `const tags = Set()` | An empty collection takes its type where it is written: `const items: List<string> = []`. A later `append`/`add`/`set` never types the declaration. A contextual position supplies it too, so `take(Set())` and `return Map()` need no annotation. |
 | `if value:` truthiness | Conditions accept only `bool`/`bool?`. Test presence explicitly: `if value != null:`. |
 | `value is null` | `value == null` / `value != null` — `is` tests runtime types, `null` is a value. |
 | `switch`, or an `if`/`else if` ladder over an enum | `match` with `case _:` as the only fallback. |
-| Renaming a binding away from `type`, `json`, `state`, `from`, `match`, `as`, `action`, `resource`, `watch`, `look`, `component` | Don't. Declaration words are contextual: each declares only in its own shape, so `const {type, from} = event` and `const state = "ready"` are ordinary code in Core and Web alike. `enum` and `case` are the exceptions — `enum` is a real VelarScript keyword, `case` is reserved by JavaScript — so neither can be a binding name; both stay fine as record fields, member names, and `match` branches. |
-| A component's `mounted:` / `cleanup:` block | `@mounted:` / `@cleanup:`. Lifecycle hooks live in the language's `@` namespace, which is why a component can also declare its own `def mounted()`. |
+| Renaming a binding away from `type`, `json`, `from`, `match`, or `as` | Don't. Declaration words are contextual: each declares only in its own shape, so `const {type, from} = event` is ordinary code. `enum` and `case` are the exceptions — `enum` is a real VelarScript keyword and `case` is reserved by JavaScript — so neither can be a binding name; both stay fine as record fields, member names, and `match` branches. |
+| Treating `@` as a decorator, call, value, or user extension point | `@` has one meaning: `@name` qualifies the name into the closed compiler-owned namespace of the current context. Core or the active syntax-owning compiler extension owns the vocabulary; source cannot declare, import, alias, pass, or construct an `@name`. The class contracts `@dispose:` and `@iterate:` follow this one rule. |
 | Two statements on one line | One statement per line; there are no semicolons. A line starting with `.` or `?.` continues the previous line, so method chains format normally. |
 | `count++` | `count += 1` |
 | `call(name: value)` named argument | `call(name=value)` |
 | Importing `range` | `range(...)` is a Core prelude function and needs no import. |
 | `import {sqrt} from "velar/math"` | `Math.sqrt(x)`; `Math.` is permanent. `velar fix` performs the rewrite. |
-| `Look.spacing(16px)` | `spacing(16px)` with `import {spacing} from "velar/look"`; the `Look.` prefix is retired. `velar fix` performs the rewrite. |
 | `"""triple-quoted"""` for a block of text | A layout string: a double quote followed immediately by a newline opens it; a quote back at the opening line's indentation closes it. Backtick strings are real, but always single-line. |
 | Escaping `\"` through a JSON, HTML, or selector string | Use backticks: `` `{"name":"Nova"}` `` is the same `string` value, with `"` as ordinary text. Prefixes are orthogonal (`` f` ``, `` r` ``, `` rf` ``), and `velar format` picks the delimiter for you (`"` by default, backticks when the text contains `"`), so write whichever is convenient. |
 | `007`, `.5` | Write `7`, `0.5`. Explicit `0xFF`, `0b1010`, and `0o17` integers are supported; legacy leading-zero octal is not. Group long digits with `_` — `1_000_000`. `Infinity` and `NaN` are not literals: write `1 / 0` and `0 / 0`. |
@@ -191,12 +121,10 @@ them; the first two are the **silent traps** in the list — read them twice.
 | A line that is only a value — `x == 5`, `items[0]`, `"a note"` | A statement must do something: call, assign, `await`, or `async`. A computed-and-discarded value is a compile error, and a bare string is not a docstring — use `//`. |
 | A block comment that starts or ends beside code on a multi-line span | `/* */` exists and nests — commenting out a region that already holds a comment works — but a multi-line one takes whole lines: only `/*` on its opening line, only `*/` on its closing line. Within a single line it can sit anywhere: `call(/* why */ value)`. |
 | `x if cond else y` | `cond ? x : y` |
-| `&&`, `\|\|`, `!`, `===`, `var`, `elif`, `None`, `undefined` | `and`, `or`, `not`, `==`, `let`/`const`, `else if`, `null`, `null`. |
+| `&&`, `\|\|`, `!value`, `===`, `var`, `elif`, `None`, `undefined` | `and`, `or`, `not value`, `==`, `let`/`const`, `else if`, `null`, `null`. `!` **after** a value is a different operator: `value!` unwraps `T?` to `T` and raises `AssertionError` when it is absent. `!=` still wins by longest match, so an unwrap before an equality test needs its space — `value! == other`. |
 | `f"{user}"` or `str(user)` on a record | Text conversion accepts strings, numbers, bools, enums, and `null` only. `print(user)` inspects a value; permanent `Json.stringify(user)` builds data text without an import. |
 | Calling an async function and moving on | A dropped Promise is a compile error. `await task()` to wait; `async task()` to run it detached. |
 | `flag or name ?? fallback` | Parenthesize — `??` never shares an unparenthesized chain with `and`/`or`. |
-| `onClick={handler}` | `on:click={handler}`; form binding is `bind:value={state}`. |
-| Implicit `{props.children}` | Declare it: a `children: WebNode` prop receives the JSX tag body. |
 | `map[key]` reads | `map.get(key)` returns `T?`. On Lists, `[index]` throws on a bug; `.get(index)` returns `null` when absence is an expected answer. |
 | `[...text]` or `list(text)` for characters | `text.split("")` — the empty separator splits per Unicode code point. |
 | `x !== x` or `Number.isNaN(x)` | Number predicates are members: `x.isNaN()`, `x.isFinite()`, `x.isInteger()`. `NaN == NaN` is `true` — equality is SameValueZero. |
@@ -235,11 +163,7 @@ it names a result. They stand next to each other most often on a callback prop
 type Transform = (value: number) -> number
 
 const double: Transform = value => value * 2
-
-component Stepper(step: number, onChange: (next: number) -> null):
-    return <button type="button" on:click={() => onChange(step + 1)}>+1</button>
-
-mount(<Stepper step={double(1)} onChange={next => print(next)} />, "#app")
+print(double(2))
 ```
 
 Parameter names in a function type are optional but worth writing:
@@ -300,7 +224,7 @@ class Session:
 const session = Session("session-1")
 ```
 
-`@name` members belong to the language and can never collide with yours.
+`@name` qualifies a compiler-owned contextual name and can never collide with yours.
 `@dispose:` is the release contract — never called directly — that
 `using name = expression` runs on every exit from the owning scope (block end,
 `return`, `break`, `continue`, throw), in reverse declaration order. A derived
@@ -312,69 +236,6 @@ escapes are rejected — return the data you read from it, or move the `using` u
 to the scope that really owns it. A JavaScript handle is owned by composition:
 hold it in a field of a class whose `@dispose:` releases it.
 
-Components (Web extension) return JSX directly — there is no `render` block.
-`state` holds a fact, `computed name = ...` derives and is read bare, `action`
-performs a user operation with reactive `pending`/`error`:
-
-```velar
-component Counter(label: string):
-    state count = 0
-    computed caption = f"{label}: {count}"
-
-    action reset():
-        count = 0
-
-    def bump():
-        count += 1
-
-    return <section>
-        <button type="button" on:click={bump}>{caption}</button>
-        <button type="button" disabled={reset.pending} on:click={reset}>Reset</button>
-    </section>
-
-mount(<Counter label="Clicks" />, "#app")
-```
-
-`look` is the checked visual language — a value, composed per element with
-`look={...}`. CSS keywords are quoted strings; property names are real DOM
-camelCase; units are literal:
-
-```velar
-import {border, rgb, spacing} from "velar/look"
-
-const buttonLook = look:
-    border = border(0px, rgb(220, 224, 235))
-    borderRadius = 10px
-    padding = spacing(10px, 14px)
-    cursor = "pointer"
-
-    if @hover:
-        background = rgb(235, 240, 255)
-
-component SaveButton(children: WebNode):
-    return <button look={buttonLook} type="button">{children}</button>
-```
-
-A `look:` literal is built once, so its conditions and values cannot read state; put a reactive visual on the element with `look={active ? a : b}` or `look:color={...}`. Declare checked motion as a module-level `keyframes:` value and pass it to `animate` from `velar/look`; disable nonessential motion at the CSS layer:
-
-```velar
-import {animate} from "velar/look"
-
-const spin = keyframes:
-    from:
-        rotate = 0deg
-    to:
-        rotate = 1turn
-
-const rotatingLook = look:
-    if not motion.reduced:
-        animation = animate(spin, 1s, easing="linear", loop=true)
-```
-
-The `animation` property accepts only `Animation`, `List<Animation>`, or `null`; a CSS animation string is rejected. Bind a changing animation on the element with `look:animation={active ? animate(spin, 1s) : null}`. Native animation longhands remain outside Look because `animate` owns the checked contract.
-
-Form state binds with `bind:value={name}` (also a writable path such as `bind:value={form.email}`), `bind:checked={flag}`, and `bind:group={choice}` — radio state holds the selected input's `value`, checkbox `List<string>` state holds the checked values; the event object has no `target`.
-
 ## The idioms
 
 These are the canonical shapes, distilled from the project's best-practices
@@ -399,8 +260,8 @@ def measure(text: string) -> TextMeasure:
 ### Null discipline
 
 One spelling per job: test presence with `!= null`, default with `??`,
-reach through maybes with `?.`, and narrow once — then use the value
-directly:
+reach through maybes with `?.`, unwrap what cannot be absent with `!`, and
+narrow once — then use the value directly:
 
 ```velar
 type Ticket:
@@ -416,6 +277,12 @@ def owner(ticket: Ticket) -> string:
     return ticket.assignee ?? "unassigned"
 ```
 
+`value!` unwraps `T?` to `T` and raises `AssertionError` where the value turns
+out to be absent — it checks, it never merely claims. Use it where absence
+would be a bug and there is nothing more to say about it, such as an index the
+code just populated. When the failure has something to tell a reader, the
+statement form says it: `assert value != null else "..."`.
+
 ### Chains over cursors
 
 Collection work is method chains; a hand-advanced index loop is the
@@ -490,11 +357,11 @@ def firstLine(text: string) -> string:
 
 Callbacks stay arrows while they are one expression; promote two-statement
 logic to a named `def`. Name arguments where a bare value would read as a
-mystery: `buttonLook(dangerous=true)`, never `buttonLook(true)`.
+mystery: `connect(retry=true)`, never `connect(true)`.
 
 ### Strings
 
-Build text with f-strings — numbers, bools, enums, and Web unit values with a declared text form interpolate directly.
+Build text with f-strings — numbers, bools, and enums interpolate directly.
 Data becomes text through permanent `Json.stringify`. Multi-line text is
 a layout string, not a stack of `\n` escapes. Text that contains `"` — a JSON
 fixture, a quoted selector — goes in backticks instead of being escaped:
@@ -516,96 +383,6 @@ print(usage)
 print(Json.stringify({open: count}))
 ```
 
-### Components: four cells, one job each
-
-`state` holds a fact. `computed` derives from facts. `resource` loads async
-data. `action` performs a user operation. Read a resource as
-`value != null`; render nothing with `null`; key dynamic children:
-
-```velar fragment
-component TicketPanel(id: string):
-    state draft = ""
-    resource ticket: Ticket = loadTicket(id)
-    computed heading = ticket.value?.title ?? "Loading"
-
-    action save():
-        await saveDraft(id, draft)
-
-    watch id:
-        async ticket.reload()
-
-    return <section>
-        <h2>{heading}</h2>
-        <textarea bind:value={draft}></textarea>
-        <button disabled={save.pending} on:click={save}>Save</button>
-    </section>
-```
-
-Lifecycle is two sibling blocks in the language's own `@` namespace —
-`@mounted:` runs once after the DOM is inserted and may `await`; `@cleanup:`
-runs once before the component is destroyed and is synchronous:
-
-```velar fragment
-component Chart(points: List<number>):
-    let canvas: CanvasElement? = null
-
-    @mounted:
-        if canvas != null:
-            drawChart(canvas, points)
-
-    @cleanup:
-        releaseChart()
-
-    return <canvas ref={canvas}></canvas>
-```
-
-**A resource loads once, at mount, and does not refetch when its inputs
-change** — a new `id` prop leaves the old data on screen. "Refetch when the
-input changes" is the `watch` above: watch the input, and start `reload()` with
-the detached `async` statement, because a watch body is synchronous. `reload()`
-re-evaluates the initializer against the current inputs, keeps the last value if
-it fails, and puts the failure in `error`. Actions do not queue either: two
-clicks run two calls, `pending` means any call is active, so guard with
-`disabled={save.pending}`.
-
-Conditional rendering is an ordinary expression — there are no magic JSX
-control-flow attributes:
-
-```velar fragment
-component Panel:
-    return <section>
-        {loading ? <p aria-busy="true">Loading…</p> : <Results items={items} />}
-        <ul>
-            {items.map(item => <li key={item.id}>{item.title}</li>)}
-        </ul>
-    </section>
-```
-
-Component props are live reactive inputs and their data is mutable by default.
-Writing `item.title = next` through a prop publishes through the same deep
-reactive path as writing the source state. Write `items: readonly List<Item>`
-when the component author deliberately wants a read-only contract; that
-explicit view travels into helpers and nested data without copying or freezing.
-
-`velar/storage` persists JSON and validates on the way back in, so a read needs
-a **named** runtime type — a primitive or generic spelling is a type, not a
-value:
-
-```velar fragment
-import {storage} from "velar/storage"
-
-type SavedItem:
-    title: string
-
-type SavedItems = List<SavedItem>
-
-const items = storage.get("reading", SavedItems, [])
-storage.set("reading", items)
-```
-
-The third argument is the fallback for missing or invalid data; `session` and
-`database(name)` from the same module carry the same shape.
-
 ### Errors and async
 
 Throw `Error` (or a subclass) with a message that names the broken rule.
@@ -700,9 +477,7 @@ data and assign the result on the Vel side.
    `undefined` even answers `false` to `== null`. The import statement is the
    only correctness boundary — validate with `Type.parse` there, before the
    value touches typed code.
-3. **Styling beyond Look** — `import css unsafe "./file.css" before look`
-   (or `after look`); trusted markup renders through `unsafe:html`.
-4. **A suspected compiler defect blocking you** — run `velar repro` (below),
+3. **A suspected compiler defect blocking you** — run `velar repro` (below),
    then take the final exit: `velar build` output is readable, source-mapped
    JavaScript that runs without the toolchain.
 
@@ -735,11 +510,9 @@ compatibility promise, changing a word costs nothing yet.
 ## Where to look up what this brief leaves out
 
 The repository carries a **tour** that shows every spelling exactly once, as
-compiling projects you can run: `examples/tour/core/` (17 numbered chapters,
-values through testing), `examples/tour/web/` (13 — components, Look, routing,
-both kinds of test), `examples/tour/desktop/` (4). When you are about to guess
-at a spelling, open the chapter instead. `examples/app/` is the companion — one
-real application, showing how the pieces are put together.
+compiling projects you can run. Core is in `examples/tour/core/`; the framework
+briefs point to their own projects. When you are about to guess at a spelling,
+open the relevant chapter instead.
 
 ## The meta-rule
 

package/dist/build-engine-tool.d.ts

@@ -1,3 +0,0 @@
-export declare const VELAR_BUILD_ENGINE_TOOL_ID = "velar-build-engine";
-export declare function buildBuildEngineTool(outputFile: string): Promise<void>;
-//# sourceMappingURL=build-engine-tool.d.ts.map

package/dist/build-engine-tool.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"build-engine-tool.d.ts","sourceRoot":"","sources":["../src/build-engine-tool.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,0BAA0B,uBAAuB,CAAC;AAE/D,wBAAsB,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAwB5E"}

package/dist/build-engine-tool.js

@@ -1,34 +0,0 @@
-import { access, chmod, copyFile, mkdir, realpath, stat } from "node:fs/promises";
-import { constants } from "node:fs";
-import { createRequire } from "node:module";
-import { dirname, isAbsolute, resolve } from "node:path";
-export const VELAR_BUILD_ENGINE_TOOL_ID = "velar-build-engine";
-export async function buildBuildEngineTool(outputFile) {
-    outputFile = resolve(outputFile);
-    const require = createRequire(import.meta.url);
-    const packageName = `@esbuild/${process.platform}-${process.arch}`;
-    let source;
-    const packagedSource = process.env.ESBUILD_BINARY_PATH;
-    if (packagedSource !== undefined) {
-        if (!isAbsolute(packagedSource) || packagedSource.length > 4096 || packagedSource.includes("\0")) {
-            throw new Error("ESBUILD_BINARY_PATH must identify a bounded absolute official build engine");
-        }
-        source = await realpath(packagedSource);
-    }
-    else {
-        try {
-            source = require.resolve(`${packageName}/bin/esbuild`);
-        }
-        catch {
-            throw new Error(`Official build engine is unavailable for ${process.platform}-${process.arch}`);
-        }
-    }
-    const information = await stat(source);
-    if (!information.isFile())
-        throw new Error("Official build engine must be an ordinary file");
-    await access(source, constants.X_OK);
-    await mkdir(dirname(outputFile), { recursive: true });
-    await copyFile(source, outputFile);
-    await chmod(outputFile, 0o755);
-}
-//# sourceMappingURL=build-engine-tool.js.map

package/dist/build-engine-tool.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"build-engine-tool.js","sourceRoot":"","sources":["../src/build-engine-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAClF,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzD,MAAM,CAAC,MAAM,0BAA0B,GAAG,oBAAoB,CAAC;AAE/D,MAAM,CAAC,KAAK,UAAU,oBAAoB,CAAC,UAAkB;IAC3D,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IACjC,MAAM,OAAO,GAAG,aAAa,CAAC,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC;IAC/C,MAAM,WAAW,GAAG,YAAY,OAAO,CAAC,QAAQ,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;IACnE,IAAI,MAAc,CAAC;IACnB,MAAM,cAAc,GAAG,OAAO,CAAC,GAAG,CAAC,mBAAmB,CAAC;IACvD,IAAI,cAAc,KAAK,SAAS,EAAE,CAAC;QACjC,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,IAAI,cAAc,CAAC,MAAM,GAAG,IAAI,IAAI,cAAc,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;YACjG,MAAM,IAAI,KAAK,CAAC,4EAA4E,CAAC,CAAC;QAChG,CAAC;QACD,MAAM,GAAG,MAAM,QAAQ,CAAC,cAAc,CAAC,CAAC;IAC1C,CAAC;SAAM,CAAC;QACN,IAAI,CAAC;YACH,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,WAAW,cAAc,CAAC,CAAC;QACzD,CAAC;QAAC,MAAM,CAAC;YACP,MAAM,IAAI,KAAK,CAAC,4CAA4C,OAAO,CAAC,QAAQ,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;QAClG,CAAC;IACH,CAAC;IACD,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,CAAC;IACvC,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;IAC7F,MAAM,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;IACrC,MAAM,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IACtD,MAAM,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACnC,MAAM,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;AACjC,CAAC"}

package/dist/packaged-official-tool.d.ts

@@ -1,8 +0,0 @@
-/**
- * A self-contained Desktop installation rebuilds only the target renderer.
- * Its official tools are immutable versioned inputs, so nested packaging
- * copies them from the Worker-validated application template instead of
- * looking for compiler sources or node_modules outside the package.
- */
-export declare function copyPackagedOfficialTool(outputFile: string, bundledRelativePath: string, mode: number): Promise<boolean>;
-//# sourceMappingURL=packaged-official-tool.d.ts.map

package/dist/packaged-official-tool.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"packaged-official-tool.d.ts","sourceRoot":"","sources":["../src/packaged-official-tool.ts"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,wBAAsB,wBAAwB,CAC5C,UAAU,EAAE,MAAM,EAClB,mBAAmB,EAAE,MAAM,EAC3B,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,OAAO,CAAC,CAmBlB"}

package/dist/packaged-official-tool.js

@@ -1,32 +0,0 @@
-import { chmod, copyFile, mkdir, realpath, stat } from "node:fs/promises";
-import { dirname, isAbsolute, join, relative, resolve } from "node:path";
-const desktopPackageTemplateEnvironment = "VELAR_DESKTOP_PACKAGE_TEMPLATE_ROOT";
-/**
- * A self-contained Desktop installation rebuilds only the target renderer.
- * Its official tools are immutable versioned inputs, so nested packaging
- * copies them from the Worker-validated application template instead of
- * looking for compiler sources or node_modules outside the package.
- */
-export async function copyPackagedOfficialTool(outputFile, bundledRelativePath, mode) {
-    const value = process.env[desktopPackageTemplateEnvironment];
-    if (value === undefined)
-        return false;
-    if (!isAbsolute(value) || value.length > 4096 || value.includes("\0")) {
-        throw new Error(`${desktopPackageTemplateEnvironment} must be a bounded absolute Desktop Resources path`);
-    }
-    const root = await realpath(value);
-    const source = await realpath(join(root, bundledRelativePath));
-    const fromRoot = relative(root, source);
-    if (fromRoot === "" || fromRoot === ".." || fromRoot.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) || isAbsolute(fromRoot)) {
-        throw new Error("Packaged official tool must stay inside the Desktop Resources template");
-    }
-    const information = await stat(source);
-    if (!information.isFile())
-        throw new Error("Packaged official tool must be an ordinary file");
-    outputFile = resolve(outputFile);
-    await mkdir(dirname(outputFile), { recursive: true });
-    await copyFile(source, outputFile);
-    await chmod(outputFile, mode);
-    return true;
-}
-//# sourceMappingURL=packaged-official-tool.js.map

package/dist/packaged-official-tool.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"packaged-official-tool.js","sourceRoot":"","sources":["../src/packaged-official-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAC1E,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzE,MAAM,iCAAiC,GAAG,qCAAqC,CAAC;AAEhF;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,wBAAwB,CAC5C,UAAkB,EAClB,mBAA2B,EAC3B,IAAY;IAEZ,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,iCAAiC,CAAC,CAAC;IAC7D,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,KAAK,CAAC;IACtC,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,GAAG,IAAI,IAAI,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QACtE,MAAM,IAAI,KAAK,CAAC,GAAG,iCAAiC,oDAAoD,CAAC,CAAC;IAC5G,CAAC;IACD,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,KAAK,CAAC,CAAC;IACnC,MAAM,MAAM,GAAG,MAAM,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,mBAAmB,CAAC,CAAC,CAAC;IAC/D,MAAM,QAAQ,GAAG,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IACxC,IAAI,QAAQ,KAAK,EAAE,IAAI,QAAQ,KAAK,IAAI,IAAI,QAAQ,CAAC,UAAU,CAAC,KAAK,OAAO,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,IAAI,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC1I,MAAM,IAAI,KAAK,CAAC,wEAAwE,CAAC,CAAC;IAC5F,CAAC;IACD,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,CAAC;IACvC,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;IAC9F,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IACjC,MAAM,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IACtD,MAAM,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACnC,MAAM,KAAK,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;IAC9B,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/project-task-bundle-entry.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=project-task-bundle-entry.d.ts.map

package/dist/project-task-bundle-entry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"project-task-bundle-entry.d.ts","sourceRoot":"","sources":["../src/project-task-bundle-entry.ts"],"names":[],"mappings":""}

package/dist/project-task-bundle-entry.js

@@ -1,18 +0,0 @@
-import { velarApplicationPackageHost as desktopApplicationPackageHost } from "@velarscript/desktop/package-host";
-import { registerBundledApplicationPackageHost } from "./bundled-application-package-host-registry.js";
-import { installOfficialLanguageServerExtensions } from "./official-language-server-extensions.js";
-import { projectTaskBrowserWorkerCliArguments, projectTaskBrowserWorkerEnvironment, projectTaskCliArguments, } from "./project-task-invocation.js";
-registerBundledApplicationPackageHost(desktopApplicationPackageHost);
-const cliArguments = process.env[projectTaskBrowserWorkerEnvironment] === undefined
-    ? projectTaskCliArguments(process.argv.slice(2))
-    : projectTaskBrowserWorkerCliArguments(process.argv.slice(2), process.env[projectTaskBrowserWorkerEnvironment]);
-if (typeof cliArguments === "string") {
-    process.stderr.write(`velar project task: ${cliArguments}\n`);
-    process.exitCode = 2;
-}
-else {
-    process.argv = [...process.argv.slice(0, 2), ...cliArguments];
-    installOfficialLanguageServerExtensions();
-    await import("./cli.js");
-}
-//# sourceMappingURL=project-task-bundle-entry.js.map

package/dist/project-task-bundle-entry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"project-task-bundle-entry.js","sourceRoot":"","sources":["../src/project-task-bundle-entry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,IAAI,6BAA6B,EAAE,MAAM,mCAAmC,CAAC;AACjH,OAAO,EAAE,qCAAqC,EAAE,MAAM,gDAAgD,CAAC;AACvG,OAAO,EAAE,uCAAuC,EAAE,MAAM,0CAA0C,CAAC;AACnG,OAAO,EACL,oCAAoC,EACpC,mCAAmC,EACnC,uBAAuB,GACxB,MAAM,8BAA8B,CAAC;AAEtC,qCAAqC,CAAC,6BAA6B,CAAC,CAAC;AAErE,MAAM,YAAY,GAAG,OAAO,CAAC,GAAG,CAAC,mCAAmC,CAAC,KAAK,SAAS;IACjF,CAAC,CAAC,uBAAuB,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAChD,CAAC,CAAC,oCAAoC,CACpC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EACrB,OAAO,CAAC,GAAG,CAAC,mCAAmC,CAAC,CACjD,CAAC;AACJ,IAAI,OAAO,YAAY,KAAK,QAAQ,EAAE,CAAC;IACrC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,uBAAuB,YAAY,IAAI,CAAC,CAAC;IAC9D,OAAO,CAAC,QAAQ,GAAG,CAAC,CAAC;AACvB,CAAC;KAAM,CAAC;IACN,OAAO,CAAC,IAAI,GAAG,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,YAAY,CAAC,CAAC;IAC9D,uCAAuC,EAAE,CAAC;IAC1C,MAAM,MAAM,CAAC,UAAU,CAAC,CAAC;AAC3B,CAAC"}

package/dist/project-task-invocation.d.ts

@@ -1,16 +0,0 @@
-export declare const projectTaskCommands: readonly ["check", "test", "browserTest", "build", "fix", "package", "run"];
-export type ProjectTaskCommand = typeof projectTaskCommands[number];
-export declare const projectTaskBrowserWorkerEnvironment = "VELAR_BROWSER_TEST_WORKER_V1";
-/**
- * Translates Desktop's closed task vocabulary into the exact public CLI
- * invocation. The host never accepts arbitrary CLI options; adding a task is
- * an explicit capability change here and in velar/desktop.
- */
-export declare function projectTaskCliArguments(arguments_: readonly string[]): readonly string[] | string;
-/**
- * The browser owner supervises its test body in a second invocation of the
- * same immutable tool. Desktop strips this private marker from the initial
- * task environment, so only the official supervisor can enter this path.
- */
-export declare function projectTaskBrowserWorkerCliArguments(arguments_: readonly string[], serializedLimits: string | undefined): readonly string[] | string;
-//# sourceMappingURL=project-task-invocation.d.ts.map

package/dist/project-task-invocation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"project-task-invocation.d.ts","sourceRoot":"","sources":["../src/project-task-invocation.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,mBAAmB,YAC9B,OAAO,EACP,MAAM,EACN,aAAa,EACb,OAAO,EACP,KAAK,EACL,SAAS,EACT,KAAK,CACG,CAAC;AAEX,MAAM,MAAM,kBAAkB,GAAG,OAAO,mBAAmB,CAAC,MAAM,CAAC,CAAC;AAEpE,eAAO,MAAM,mCAAmC,iCAAiC,CAAC;AAMlF;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,MAAM,EAAE,GAAG,MAAM,CAajG;AAED;;;;GAIG;AACH,wBAAgB,oCAAoC,CAClD,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,gBAAgB,EAAE,MAAM,GAAG,SAAS,GACnC,SAAS,MAAM,EAAE,GAAG,MAAM,CA4B5B"}