feat: render top-level Endor scripts through embedded Aster
Verify Tessera GUI / verify (push) Failing after 6m52s
Verify Tessera GUI / verify (push) Failing after 6m52s
This commit is contained in:
@@ -8,4 +8,8 @@ The container includes the Endor examples used by the live guide and tests. It
|
||||
validates the actual Aster-backed source-to-UI path, snapshot lifetime, layout and
|
||||
execution budgets, failed-update preservation and stale-result invalidation, in
|
||||
addition to the existing rendering checks and Clippy. Cargo uses official sources.
|
||||
The primary example now executes top-level let statements and ui.page().render
|
||||
through Aster's Interactive interface. Function-entry compatibility, original
|
||||
source positions, page methods and page budgets are also checked. The workflow
|
||||
checks the macOS packaging script's syntax without running it on Linux.
|
||||
Docker is used only in this remote workflow; local compilation is native.
|
||||
|
||||
@@ -43,6 +43,7 @@ jobs:
|
||||
|
||||
- name: Verify portable GUI code
|
||||
run: |
|
||||
sh -n scripts/build-macos-app.sh
|
||||
image="endorphin-tessera-gui-ci:${{ gitea.sha }}"
|
||||
docker build -f Dockerfile.ci -t "$image" .
|
||||
docker run --rm --init "$image"
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
# Tessera
|
||||
|
||||
Tessera is a native desktop UI host embedding [Aster](vendor/aster/README.md).
|
||||
Agents submit ordinary Endor source through a local namespace API. Aster parses,
|
||||
compiles and executes it; `main` returns a Tessera UI object. Tessera extracts a
|
||||
Agents submit ordinary Endor scripts through a local namespace API. Aster parses,
|
||||
compiles and executes them; `ui.page().render(root)` selects a Tessera UI tree. Tessera extracts a
|
||||
native tree, lays it out and draws it using the existing software renderer.
|
||||
The initial page is empty.
|
||||
|
||||
@@ -33,8 +33,15 @@ cargo build --release --locked
|
||||
Cargo compiles the required Aster libraries together with Tessera. No separate
|
||||
Aster build, service or deployment is required. Local builds download dependencies
|
||||
from official crates.io; do not substitute a mirror. Docker and automated tests
|
||||
are not used locally. On macOS this produces a native executable, not an `.app`
|
||||
bundle or installer.
|
||||
are not used locally. The command above produces a native executable. To create a
|
||||
Finder-launchable development app on macOS, run:
|
||||
|
||||
```bash
|
||||
sh scripts/build-macos-app.sh
|
||||
```
|
||||
|
||||
Open `target/release/Tessera.app`. See [packaging](scripts/README.md); this local
|
||||
bundle does not include distribution signing, notarization or an installer.
|
||||
|
||||
The API listens only on `127.0.0.1:4737`. Start integrations with its live guide:
|
||||
|
||||
@@ -52,30 +59,39 @@ PUT /v1/namespaces/app.main/code
|
||||
DELETE /v1/namespaces/app.main/code
|
||||
```
|
||||
|
||||
Submit the [complete example](examples/hello.endor):
|
||||
Submit the [complete example](examples/page.endor):
|
||||
|
||||
```bash
|
||||
curl --request PUT --header 'Content-Type: text/plain; charset=utf-8' \
|
||||
--data-binary @examples/hello.endor \
|
||||
--data-binary @examples/page.endor \
|
||||
http://127.0.0.1:4737/v1/namespaces/app.main/code
|
||||
```
|
||||
|
||||
A minimal program is:
|
||||
|
||||
```endor
|
||||
function main(): View {
|
||||
let title = ui.text("Hello Endor", 2, "#242422")
|
||||
let rectangle = ui.rect(240, 80, 12, "#DCE8FF")
|
||||
return ui.column(24, 12, title, rectangle)
|
||||
}
|
||||
let heading = ui.text("Hello Endor", 2, "#242422")
|
||||
let rectangle = ui.rect(240, 80, 12, "#DCE8FF")
|
||||
let myui = ui.page()
|
||||
myui.render(ui.column(24, 12, heading, rectangle))
|
||||
```
|
||||
|
||||
The namespace comes from the request path. `ui` is a host global declared to
|
||||
Aster's compiler and injected into the candidate VM. Function declarations,
|
||||
helper calls, local variables, member reads and positional arguments use Aster's
|
||||
existing language implementation. `View` is currently a syntactic annotation;
|
||||
Tessera validates the actual returned object. This does not add syntax to Endor.
|
||||
The sample file is client-side material; the API itself stores source by namespace.
|
||||
Aster's compiler and injected into the candidate VM. Top-level variables share
|
||||
that VM's globals within this source submission. No `main` wrapper is generated.
|
||||
Complete top-level inputs are separated by newlines; multiline calls and function
|
||||
bodies are grouped before being handed to Aster's existing Interactive parser and
|
||||
compiler. Expression continuations such as a member read on the following line
|
||||
remain in the same input. Aster still owns every token, syntax rule, AST and
|
||||
bytecode operation; the host only batches inputs and restores original AST offsets.
|
||||
|
||||
The older [main-returning-View example](examples/main.endor) and the richer
|
||||
[function example](examples/hello.endor) remain supported. A source consisting
|
||||
entirely of function declarations uses Aster's Module entry and calls zero-argument
|
||||
`main`. Mixed function declarations, bindings and expression statements use
|
||||
Interactive inputs in source order. Type annotations remain syntactic in Aster;
|
||||
Tessera checks actual UI values. The sample files are client-side material; the
|
||||
API itself stores source by namespace.
|
||||
|
||||
## UI host API
|
||||
|
||||
@@ -89,29 +105,37 @@ not Endor keyword argument syntax.
|
||||
| `ui.column` | Padding, gap, followed by zero or more UI children |
|
||||
| `ui.row` | Padding, gap, followed by zero or more UI children |
|
||||
| `ui.spacer` | Size |
|
||||
| `ui.page` | No arguments; creates a page with a bound `render(root)` member |
|
||||
|
||||
Colors are `#RRGGBB` or `#RRGGBBAA`. Dimensions are finite numbers in 0..1000000.
|
||||
A namespace has one displayed page. If a script creates several pages or renders
|
||||
more than once, its final successful render selects the visible root. Rendering
|
||||
does not publish partial execution: a later error rejects the entire submission.
|
||||
|
||||
Aster keeps its exact numeric representation; conversion occurs only at the UI
|
||||
boundary. Text uses the current bitmap renderer, with Chinese fonts still pending.
|
||||
|
||||
## Candidate execution and publication
|
||||
|
||||
A dedicated worker performs source parsing, AST budget checks, compilation,
|
||||
module initialization and zero-argument `main` execution in a fresh VM. It checks
|
||||
the returned UI node, extracts native data, builds and validates the frame, then
|
||||
A dedicated worker performs source parsing, AST budget checks and compilation in
|
||||
a fresh candidate VM. It executes each script input with shared globals (or module
|
||||
initialization and zero-argument `main` for function-only source), checks the
|
||||
selected UI root, extracts native data, builds and validates the frame, then
|
||||
cleans up all VM roots. The window receives no VM handles. It relays out the owned
|
||||
native tree during redraw and display scale changes without rerunning Endor.
|
||||
|
||||
The existing callback interface has no allocator access. Tessera therefore
|
||||
preallocates at most 4096 real UI objects per candidate. Each is initialized once.
|
||||
preallocates 4096 real UI node objects plus a separate 64-page pool with bound
|
||||
render callbacks per candidate. Each constructed node is initialized once.
|
||||
Constructors return those borrowed handles; Aster retains call results under its
|
||||
existing rules. Native child data owns its own lifetime and contains no managed
|
||||
VM edges. This bounded pool is for snapshot construction, not a persistent dynamic UI.
|
||||
|
||||
Limits are 1 MiB source, 10000 visited AST nodes with a 64-level visitor depth,
|
||||
4096 constructed UI nodes, 64 UI levels, 10000 expanded layout visits and 16 KiB
|
||||
per text. VM initialization and entry execution each have a 128-frame and 1000000-
|
||||
instruction budget. Repeated children count again during layout, preventing a
|
||||
4096 constructed UI nodes, 64 pages, 64 UI levels, 10000 expanded layout visits
|
||||
and 16 KiB per text. Every execution has a 128-frame limit. Script inputs each
|
||||
receive an equal share of a total 1000000-instruction allowance; function-only
|
||||
module initialization and main execution each retain a 1000000-instruction budget. Repeated children count again during layout, preventing a
|
||||
small shared tree from expanding without bound. The build queue holds eight
|
||||
pending requests.
|
||||
|
||||
@@ -144,7 +168,7 @@ maintain a second language AST.
|
||||
|
||||
Local native builds and window runs are allowed; do not run local automated tests
|
||||
or Docker. [Remote CI](.gitea/README.md) on ces-control runs the existing renderer
|
||||
checks and the new Aster execution, UI layout, source-range, lifetime, budget,
|
||||
checks and the new Aster script/module execution, page rendering, UI layout, source-range, lifetime, budget,
|
||||
failed-update and deletion-invalidation regressions, plus Clippy.
|
||||
The API regressions use actual HTTP requests, including DELETE while the worker
|
||||
is occupied and a queued PUT is superseded.
|
||||
|
||||
+8
-4
@@ -1,11 +1,15 @@
|
||||
# Endor UI examples
|
||||
|
||||
[hello.endor](hello.endor) returns a native UI tree using an ordinary helper
|
||||
function and `main`. It covers text, a rounded rectangle, row/column layout and
|
||||
spacing. Submit it as the UTF-8 body of a namespace PUT request; no namespace,
|
||||
| File | Purpose |
|
||||
| --- | --- |
|
||||
| [page.endor](page.endor) | Four top-level statements construct text, a rectangle and a page, then call page.render; no main wrapper. |
|
||||
| [main.endor](main.endor) | The earlier function-entry form, producing the same frame as page.endor. |
|
||||
| [hello.endor](hello.endor) | Richer function-entry example covering a helper, Row/Column and Spacer. |
|
||||
|
||||
Submit a file as the UTF-8 body of a namespace PUT request. No namespace,
|
||||
scene, render block or imports belong in the source.
|
||||
|
||||
The live `/agent` guide embeds this exact example. Remote CI executes it through
|
||||
The live `/agent` guide embeds page.endor exactly. Remote CI executes the examples through
|
||||
Aster and checks the resulting coordinates and source ranges after VM cleanup.
|
||||
The file is client-side sample material; Tessera's API stores source by namespace.
|
||||
|
||||
|
||||
@@ -0,0 +1,5 @@
|
||||
function main(): View {
|
||||
let heading = ui.text("Hello Endor", 2, "#242422")
|
||||
let rectangle = ui.rect(240, 80, 12, "#DCE8FF")
|
||||
return ui.column(24, 12, heading, rectangle)
|
||||
}
|
||||
@@ -0,0 +1,4 @@
|
||||
let heading = ui.text("Hello Endor", 2, "#242422")
|
||||
let rectangle = ui.rect(240, 80, 12, "#DCE8FF")
|
||||
let myui = ui.page()
|
||||
myui.render(ui.column(24, 12, heading, rectangle))
|
||||
@@ -0,0 +1,14 @@
|
||||
# Native packaging
|
||||
|
||||
`build-macos-app.sh` builds the release executable with the normal Cargo lockfile
|
||||
and creates `target/release/Tessera.app`. It uses the local Rust toolchain and
|
||||
official Cargo sources; no mirror or Docker configuration is installed, and no
|
||||
automated tests run. `CARGO_NET_OFFLINE=true` can reuse an already populated
|
||||
official dependency cache.
|
||||
|
||||
The local bundle has identifier `com.entroia.tessera` and can be opened from Finder.
|
||||
It is a development app, without a distribution signature or notarization.
|
||||
The CI workflow only checks this script's shell syntax on Linux; native bundle
|
||||
construction and window presentation are verified on macOS.
|
||||
|
||||
Return to the [project guide](../README.md).
|
||||
Executable
+31
@@ -0,0 +1,31 @@
|
||||
#!/bin/sh
|
||||
# Native macOS build and app bundle. No Docker, mirror configuration, or tests.
|
||||
set -eu
|
||||
if [ "$(uname -s)" != Darwin ]; then
|
||||
echo "Build this app bundle on macOS." >&2
|
||||
exit 1
|
||||
fi
|
||||
cd "$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)"
|
||||
cargo build --release --locked
|
||||
version=$(awk -F '"' '$1 ~ /^version[[:space:]]*=/ { print $2; exit }' Cargo.toml)
|
||||
test -n "$version"
|
||||
bundle="$(pwd)/target/release/Tessera.app"
|
||||
mkdir -p "$bundle/Contents/MacOS"
|
||||
cp target/release/tessera "$bundle/Contents/MacOS/tessera.new"
|
||||
mv -f "$bundle/Contents/MacOS/tessera.new" "$bundle/Contents/MacOS/tessera"
|
||||
cat > "$bundle/Contents/Info.plist.new" <<PLIST
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
|
||||
<plist version="1.0"><dict>
|
||||
<key>CFBundleIdentifier</key><string>com.entroia.tessera</string>
|
||||
<key>CFBundleName</key><string>Tessera</string>
|
||||
<key>CFBundleDisplayName</key><string>Tessera</string>
|
||||
<key>CFBundleExecutable</key><string>tessera</string>
|
||||
<key>CFBundlePackageType</key><string>APPL</string>
|
||||
<key>CFBundleShortVersionString</key><string>$version</string>
|
||||
<key>CFBundleVersion</key><string>$version</string>
|
||||
<key>NSHighResolutionCapable</key><true/>
|
||||
</dict></plist>
|
||||
PLIST
|
||||
mv -f "$bundle/Contents/Info.plist.new" "$bundle/Contents/Info.plist"
|
||||
printf '%s\n' "$bundle"
|
||||
+11
-5
@@ -4,8 +4,9 @@
|
||||
| --- | --- |
|
||||
| main.rs | Native window event loop, namespace state and API startup |
|
||||
| api.rs | Code CRUD, eight-entry execution queue, worker, submission ordering and diagnostics |
|
||||
| endor_host.rs | Aster Reader/Parser/Compiler, fresh candidate VM, limited initialization/main execution, root cleanup and AST developer tree |
|
||||
| ui_bridge.rs | Tessera UI constructors and payloads, bounded preallocated node pool and native snapshot extraction |
|
||||
| endor_host.rs | Aster compilation, fresh candidate VM, bounded script/module execution, root cleanup and AST developer tree |
|
||||
| endor_script.rs | Batch complete inputs for Aster's Interactive parser/compiler, retain Module entry, and rebase Aster spans to the original snapshot |
|
||||
| ui_bridge.rs | Tessera UI/page payloads and bound render methods, preallocated node/page pools and native snapshot extraction |
|
||||
| layout.rs | Native UI tree to Frame; expanded-tree and coordinate budgets |
|
||||
| document.rs | Published source/AST/UI snapshot, revisions, invalidation, frame validation and display commands |
|
||||
| app.rs | Window events, redraw and developer-tools input |
|
||||
@@ -21,14 +22,19 @@ compilation, bytecode and VM execution come from its libraries. Tessera implemen
|
||||
only host UI behavior and layout. No CLI, HTTP server or Docker process is needed
|
||||
to execute Endor in the application.
|
||||
|
||||
An execution candidate owns all external VM roots, including the 4096-node pool.
|
||||
An execution candidate owns all external VM roots, including the 4096-node pool
|
||||
and 64 pages with bound render callbacks. Script units share one globals dictionary
|
||||
inside the candidate; no variables or VM handles persist across successful PUTs.
|
||||
Callbacks return borrowed, preallocated real VM objects. Their mutable slots hold
|
||||
immutable native UI descriptions; child edges contain owned native Arcs, never
|
||||
managed VM references. Once extraction finishes, release the return value, clear
|
||||
managed VM references. Page rendering stores native root data in the build session;
|
||||
the final render selects the snapshot after all script units succeed. Once
|
||||
extraction finishes, release temporary results, clear
|
||||
globals, release roots, collect cycles and require an empty VM. The window keeps
|
||||
only source, developer metadata, frame commands and native UI data.
|
||||
|
||||
Tests in api.rs execute real HTTP CRUD and a controlled queued-PUT/DELETE race
|
||||
without opening a window. Tests in endor_host.rs cover lifecycle, normal Endor calls, malformed input,
|
||||
without opening a window. Tests in endor_host.rs cover lifecycle, direct script and
|
||||
module entry, page methods, multiline inputs, original source ranges, malformed input,
|
||||
entry checks, budgets, failure preservation and stale-result invalidation. They
|
||||
run only in remote CI. See the [project guide](../README.md) for public behavior.
|
||||
|
||||
+17
-10
@@ -299,9 +299,10 @@ fn agent_guide(namespace: &NamespaceState) -> String {
|
||||
Current namespace: `{name}`
|
||||
Current revision: `{revision}`
|
||||
|
||||
Submit ordinary Endor functions. Tessera embeds Aster's frontend, compiler and VM.
|
||||
The namespace comes from the request path. Declare a zero-argument `main` returning
|
||||
a UI node. Type annotations are currently syntax only in Aster.
|
||||
Submit an ordinary Endor script. Tessera embeds Aster's frontend, compiler and VM.
|
||||
The namespace comes from the request path. Top-level bindings share the candidate
|
||||
VM's globals; `ui.page().render(root)` selects the visible UI. No main function is
|
||||
required. Typed helper functions and the older main-returning-View form also work.
|
||||
|
||||
## Code CRUD
|
||||
|
||||
@@ -322,11 +323,17 @@ Positional arguments only:
|
||||
- `ui.rect(width, height, radius = 0, color = "#DCE8FF")`.
|
||||
- `ui.column(padding, gap, child...)` and `ui.row(padding, gap, child...)`.
|
||||
- `ui.spacer(size)`.
|
||||
- `ui.page()` creates a page; `page.render(root)` sets its root. The last render
|
||||
in a successful submission selects the page shown in this namespace.
|
||||
|
||||
Defaults above describe the host API; do not write keyword arguments in Endor.
|
||||
Colors use #RRGGBB or #RRGGBBAA. Dimensions are finite numbers in 0..1000000.
|
||||
Limits: 1 MiB source, 4096 constructed nodes, 64 UI levels, 10000 expanded layout
|
||||
nodes, 16 KiB per text, 128 VM frames and 1000000 instructions per execution.
|
||||
Use newlines between complete top-level statements. Multiline calls, function
|
||||
bodies and expression continuations are passed to Aster as complete inputs.
|
||||
Limits: 1 MiB source, 4096 constructed nodes, 64 pages, 64 UI levels, 10000 expanded
|
||||
layout nodes, 16 KiB per text, 128 VM frames. Script statements each receive an
|
||||
equal share of a total 1000000-instruction allowance. Older module initialization
|
||||
and main execution each retain their own 1000000-instruction allowance.
|
||||
|
||||
PUT waits for its worker result. Errors return 422 with diagnostics and preserve
|
||||
the last successful revision. A newer accepted PUT or DELETE supersedes older
|
||||
@@ -339,7 +346,7 @@ future work. It is not an untrusted-code sandbox.
|
||||
name = namespace.name,
|
||||
revision = namespace.revision,
|
||||
address = API_ADDRESS,
|
||||
example = include_str!("../examples/hello.endor"),
|
||||
example = include_str!("../examples/page.endor"),
|
||||
)
|
||||
}
|
||||
|
||||
@@ -466,10 +473,10 @@ mod tests {
|
||||
api: Some(api),
|
||||
};
|
||||
let route = "/v1/namespaces/app.main/code";
|
||||
let example = include_str!("../examples/hello.endor");
|
||||
let example = include_str!("../examples/page.endor");
|
||||
let (status, _, guide) = client.request("GET", "/agent", "");
|
||||
assert_eq!(status, 200);
|
||||
assert!(guide.contains("function main(): View"));
|
||||
assert!(guide.contains("let myui = ui.page()"));
|
||||
let (status, _, body) = client.request("PUT", route, example);
|
||||
assert_eq!(status, 200, "{body}");
|
||||
assert_eq!(
|
||||
@@ -540,7 +547,7 @@ mod tests {
|
||||
let release = Release(release_tx);
|
||||
let client = &client;
|
||||
let route = "/v1/namespaces/app.main/code";
|
||||
let example = include_str!("../examples/hello.endor");
|
||||
let example = include_str!("../examples/page.endor");
|
||||
let first = scope.spawn(move || client.request("PUT", route, example));
|
||||
entered_rx.recv_timeout(Duration::from_secs(10)).unwrap();
|
||||
let pending = scope.spawn(move || client.request("PUT", route, example));
|
||||
@@ -573,7 +580,7 @@ mod tests {
|
||||
fn guide_contains_only_code_crud_routes() {
|
||||
let guide = agent_guide(&NamespaceState::default());
|
||||
assert!(guide.contains("Code CRUD"));
|
||||
assert!(guide.contains("function main(): View"));
|
||||
assert!(guide.contains("let myui = ui.page()"));
|
||||
assert!(!guide.contains("export scene"));
|
||||
assert!(guide.contains("PUT http://127.0.0.1:4737"));
|
||||
assert!(!guide.contains("display_list"));
|
||||
|
||||
+296
-44
@@ -2,12 +2,14 @@
|
||||
use anyhow::{Result, bail};
|
||||
use endor_core::{ExecutionLimits, ObjectRef, Value, Vm, VmError};
|
||||
use frontend::{
|
||||
EndorReader, ParseMode, SourceUnit, Span,
|
||||
EndorReader, SourceUnit, Span,
|
||||
ast::{AstRoot, Decl, DeclKind, Expr, ExprKind, Spanned, Stmt, StmtKind, visitor::Visitor},
|
||||
};
|
||||
use std::collections::BTreeSet;
|
||||
|
||||
use crate::{
|
||||
document::{CodeNode, RenderDocument},
|
||||
endor_script::{self, SourcePlan},
|
||||
layout, ui_bridge,
|
||||
};
|
||||
|
||||
@@ -24,47 +26,64 @@ pub fn compile(source: &str, namespace: &str, submission: u64) -> Result<RenderD
|
||||
bail!("source exceeds the 1 MiB limit");
|
||||
}
|
||||
let source = EndorReader::from_text(format!("{namespace} [submission {submission}]"), source);
|
||||
let ast = frontend::parse_source_ast(&source, ParseMode::Module)?;
|
||||
AstBudget::default().visit_ast_root(&ast)?;
|
||||
let compiled = compiler::compile_ast(
|
||||
&ast,
|
||||
&source,
|
||||
&compiler::CompileOptions {
|
||||
globals: vec!["ui".into()],
|
||||
},
|
||||
)
|
||||
.map_err(|error| source.annotate(error))?;
|
||||
let root = architecture(&source, &ast, namespace);
|
||||
let plan = endor_script::parse(&source)?;
|
||||
let mut budget = AstBudget::default();
|
||||
for ast in plan.roots() {
|
||||
budget.visit_ast_root(ast)?;
|
||||
}
|
||||
let compiled = compile_plan(&source, &plan)?;
|
||||
let root = architecture(&source, &plan, namespace, submission);
|
||||
let mut candidate = Candidate::new()?;
|
||||
let result: Result<RenderDocument> = (|| {
|
||||
let globals = candidate.vm.new_dict()?;
|
||||
candidate.globals = Some(globals);
|
||||
candidate.roots.push(globals);
|
||||
let ui = ui_bridge::install(&mut candidate.vm, &mut candidate.roots)?;
|
||||
let bridge = ui_bridge::install(&mut candidate.vm, &mut candidate.roots)?;
|
||||
candidate
|
||||
.vm
|
||||
.dict_set(globals, Value::Text("ui".into()), Value::Object(ui))?;
|
||||
let code = compiled.load(&mut candidate.vm)?;
|
||||
candidate.roots.push(code);
|
||||
let initialized = candidate
|
||||
.vm
|
||||
.execute_with_limits(code, globals, LIMITS)
|
||||
.map_err(|error| runtime_error(&candidate.vm, error))?;
|
||||
candidate.vm.release_value(initialized)?;
|
||||
let entry = candidate
|
||||
.vm
|
||||
.dict_get(globals, &Value::Text("main".into()))?
|
||||
.ok_or_else(|| anyhow::anyhow!("source must declare function main(): View"))?;
|
||||
let Value::Object(entry) = entry else {
|
||||
bail!("main must be a callable function");
|
||||
.dict_set(globals, Value::Text("ui".into()), Value::Object(bridge.ui))?;
|
||||
let limits = match &plan {
|
||||
SourcePlan::Module(_) => LIMITS,
|
||||
SourcePlan::Script(_) => ExecutionLimits {
|
||||
max_instructions: LIMITS.max_instructions / compiled.len().max(1),
|
||||
..LIMITS
|
||||
},
|
||||
};
|
||||
for template in &compiled {
|
||||
let code = template.load(&mut candidate.vm)?;
|
||||
candidate.roots.push(code);
|
||||
let value = candidate
|
||||
.vm
|
||||
.execute_with_limits(code, globals, limits)
|
||||
.map_err(|error| runtime_error(&candidate.vm, error))?;
|
||||
candidate.vm.release_value(value)?;
|
||||
}
|
||||
let ui_root = match &plan {
|
||||
SourcePlan::Script(_) => bridge
|
||||
.rendered()?
|
||||
.ok_or_else(|| anyhow::anyhow!("script must call ui.page().render(root)"))?,
|
||||
SourcePlan::Module(_) => {
|
||||
let entry = candidate
|
||||
.vm
|
||||
.dict_get(globals, &Value::Text("main".into()))?
|
||||
.ok_or_else(|| {
|
||||
anyhow::anyhow!("declare main or render a page from a top-level script")
|
||||
})?;
|
||||
let Value::Object(entry) = entry else {
|
||||
bail!("main must be a callable function");
|
||||
};
|
||||
let value = candidate
|
||||
.vm
|
||||
.call_with_limits(entry, &[], LIMITS)
|
||||
.map_err(|error| runtime_error(&candidate.vm, error))?;
|
||||
let snapshot = bridge.rendered().and_then(|rendered| match rendered {
|
||||
Some(root) => Ok(root),
|
||||
None => ui_bridge::snapshot(&candidate.vm, &value),
|
||||
});
|
||||
candidate.vm.release_value(value)?;
|
||||
snapshot?
|
||||
}
|
||||
};
|
||||
let returned = candidate
|
||||
.vm
|
||||
.call_with_limits(entry, &[], LIMITS)
|
||||
.map_err(|error| runtime_error(&candidate.vm, error))?;
|
||||
let snapshot = ui_bridge::snapshot(&candidate.vm, &returned);
|
||||
candidate.vm.release_value(returned)?;
|
||||
let ui_root = snapshot?;
|
||||
let document = RenderDocument {
|
||||
source: source.text().to_owned(),
|
||||
root: Some(root),
|
||||
@@ -82,6 +101,41 @@ pub fn compile(source: &str, namespace: &str, submission: u64) -> Result<RenderD
|
||||
}
|
||||
}
|
||||
|
||||
fn compile_plan(source: &SourceUnit, plan: &SourcePlan) -> Result<Vec<compiler::CompiledCode>> {
|
||||
let mut globals = BTreeSet::from(["ui".to_owned()]);
|
||||
// Match Aster module behavior for function forward references. Bindings are
|
||||
// added in source order; every executable statement still uses Aster's own
|
||||
// single-input Interactive compiler and the candidate's shared globals.
|
||||
for root in plan.roots() {
|
||||
if let AstRoot::Interactive(input) = root {
|
||||
for statement in &input.statements {
|
||||
if let StmtKind::Declaration(decl) = &statement.kind {
|
||||
let DeclKind::Function(function) = &decl.kind;
|
||||
globals.insert(function.name.text.clone());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut compiled = Vec::with_capacity(plan.roots().len());
|
||||
for root in plan.roots() {
|
||||
let options = compiler::CompileOptions {
|
||||
globals: globals.iter().cloned().collect(),
|
||||
};
|
||||
compiled.push(
|
||||
compiler::compile_ast(root, source, &options)
|
||||
.map_err(|error| source.annotate(error))?,
|
||||
);
|
||||
if let AstRoot::Interactive(input) = root {
|
||||
for statement in &input.statements {
|
||||
if let StmtKind::Binding(binding) = &statement.kind {
|
||||
globals.insert(binding.name.text.clone());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(compiled)
|
||||
}
|
||||
|
||||
struct Candidate {
|
||||
vm: Vm,
|
||||
roots: Vec<ObjectRef>,
|
||||
@@ -160,20 +214,43 @@ impl Visitor for AstBudget {
|
||||
}
|
||||
}
|
||||
|
||||
fn architecture(source: &SourceUnit, ast: &AstRoot, namespace: &str) -> CodeNode {
|
||||
fn architecture(
|
||||
source: &SourceUnit,
|
||||
plan: &SourcePlan,
|
||||
namespace: &str,
|
||||
submission: u64,
|
||||
) -> CodeNode {
|
||||
let mut tree = Architecture {
|
||||
line_starts: line_starts(source.text()),
|
||||
next_id: 0,
|
||||
identity: format!("{namespace}@{submission}"),
|
||||
};
|
||||
let AstRoot::Module(program) = ast else {
|
||||
unreachable!("module parse mode");
|
||||
let mut children = Vec::new();
|
||||
for root in plan.roots() {
|
||||
match root {
|
||||
AstRoot::Module(program) => children.extend(
|
||||
program
|
||||
.declarations
|
||||
.iter()
|
||||
.map(|decl| tree.declaration(decl)),
|
||||
),
|
||||
AstRoot::Interactive(input) => {
|
||||
children.extend(input.statements.iter().map(|stmt| tree.statement(stmt)))
|
||||
}
|
||||
AstRoot::Expression(expression) => children.push(tree.expression(expression)),
|
||||
}
|
||||
}
|
||||
let roots = plan.roots();
|
||||
let span = Span::new(
|
||||
roots.first().map_or(0, |root| root.span().start),
|
||||
roots.last().map_or(0, |root| root.span().end),
|
||||
);
|
||||
let kind = if matches!(plan, SourcePlan::Module(_)) {
|
||||
"module"
|
||||
} else {
|
||||
"script"
|
||||
};
|
||||
let children = program
|
||||
.declarations
|
||||
.iter()
|
||||
.map(|decl| tree.declaration(decl))
|
||||
.collect();
|
||||
tree.node(namespace.to_owned(), "module", ast.span(), children)
|
||||
tree.node(namespace.to_owned(), kind, span, children)
|
||||
}
|
||||
|
||||
fn line_starts(source: &str) -> Vec<usize> {
|
||||
@@ -190,6 +267,7 @@ fn line_starts(source: &str) -> Vec<usize> {
|
||||
struct Architecture {
|
||||
line_starts: Vec<usize>,
|
||||
next_id: usize,
|
||||
identity: String,
|
||||
}
|
||||
|
||||
impl Architecture {
|
||||
@@ -198,7 +276,7 @@ impl Architecture {
|
||||
self.next_id += 1;
|
||||
let line = |offset| self.line_starts.partition_point(|start| *start <= offset);
|
||||
CodeNode {
|
||||
id: format!("ast-{id}"),
|
||||
id: format!("{}:ast-{id}", self.identity),
|
||||
name,
|
||||
kind: kind.into(),
|
||||
start_line: line(span.start),
|
||||
@@ -280,6 +358,180 @@ mod tests {
|
||||
use crate::document::{NamespaceState, RenderCommand};
|
||||
|
||||
const EXAMPLE: &str = include_str!("../examples/hello.endor");
|
||||
const PAGE: &str = include_str!("../examples/page.endor");
|
||||
|
||||
#[test]
|
||||
fn top_level_goal_script_renders_without_a_main_or_synthetic_wrapper() {
|
||||
let document = compile(PAGE, "app.main", 9).unwrap();
|
||||
assert_eq!(document.source, PAGE);
|
||||
let tree = document.root.as_ref().unwrap();
|
||||
assert_eq!(tree.kind, "script");
|
||||
assert_eq!(tree.children.len(), 4);
|
||||
assert_eq!(tree.children[0].name, "heading");
|
||||
assert_eq!(tree.children[1].name, "rectangle");
|
||||
assert_eq!(tree.children[2].name, "myui");
|
||||
assert_eq!(tree.children[2].start_line, 3);
|
||||
assert_eq!(tree.children[3].start_line, 4);
|
||||
assert!(tree.id.contains("app.main@9"));
|
||||
assert_eq!(document.frame.commands.len(), 2);
|
||||
assert!(
|
||||
matches!(&document.frame.commands[0], RenderCommand::Text { value, size: 2, x: 24.0, y: 24.0, .. } if value == "Hello Endor")
|
||||
);
|
||||
assert!(
|
||||
matches!(&document.frame.commands[1], RenderCommand::RoundedRect { x: 24.0, y: 52.0, width: 240.0, height: 80.0, radius: 12.0, color } if color == "#DCE8FF")
|
||||
);
|
||||
assert_eq!(document.display_list(2.0).unwrap().commands().len(), 3);
|
||||
let wrapped = compile(include_str!("../examples/main.endor"), "app.main", 10).unwrap();
|
||||
assert_eq!(
|
||||
serde_json::to_value(&document.frame).unwrap(),
|
||||
serde_json::to_value(&wrapped.frame).unwrap()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn script_helpers_multiline_bindings_calls_and_member_continuations_use_aster() {
|
||||
let source = r##"let color = "#242422" // comment with ( and )
|
||||
function greeting(): Text {
|
||||
return "Hello Endor"
|
||||
}
|
||||
function heading(value: Text): View {
|
||||
return ui.text(value, 2, color)
|
||||
}
|
||||
let title =
|
||||
heading(greeting())
|
||||
let rectangle = ui.rect(
|
||||
240, 80, 12,
|
||||
"#DCE8FF"
|
||||
)
|
||||
let page = ui
|
||||
.page()
|
||||
page
|
||||
.render(ui.column(24, 12, title, rectangle))
|
||||
"##;
|
||||
let document = compile(source, "app.main", 2).unwrap();
|
||||
assert_eq!(document.frame.commands.len(), 2);
|
||||
let tree = document.root.unwrap();
|
||||
assert_eq!(tree.children[1].name, "greeting");
|
||||
assert_eq!(tree.children[1].start_line, 2);
|
||||
assert_eq!(tree.children[2].name, "heading");
|
||||
assert_eq!(tree.children[2].start_line, 5);
|
||||
assert_eq!(tree.children[3].start_line, 8);
|
||||
assert_eq!(tree.children[3].end_line, 9);
|
||||
assert_eq!(tree.children.last().unwrap().end_line, 17);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn script_diagnostics_refer_to_original_unicode_source_and_byte_ranges() {
|
||||
for ending in ["\n", "\r\n", "\r"] {
|
||||
let source = format!(
|
||||
"let title = ui.text(\"中文\"){ending}// comment{ending}let broken = missing{ending}ui.page().render(title)"
|
||||
);
|
||||
let error = compile(&source, "app.main", 27).unwrap_err();
|
||||
let diagnostic = error.downcast_ref::<frontend::SourceDiagnostic>().unwrap();
|
||||
assert_eq!(diagnostic.location.line, 3);
|
||||
assert_eq!(diagnostic.location.column, 14);
|
||||
assert_eq!(diagnostic.diagnostic.span.slice(&source), Some("missing"));
|
||||
assert!(diagnostic.origin.to_string().contains("submission 27"));
|
||||
}
|
||||
let error = compile("let page = ui.page()\npage.render(,)", "app.main", 1).unwrap_err();
|
||||
let diagnostic = error.downcast_ref::<frontend::SourceDiagnostic>().unwrap();
|
||||
assert_eq!(diagnostic.location.line, 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pages_bind_render_methods_and_last_render_selects_the_snapshot() {
|
||||
let source = r#"let first = ui.page()
|
||||
let second = ui.page()
|
||||
first.render(ui.text("first"))
|
||||
second.render(ui.text("second"))
|
||||
let paint = first.render
|
||||
paint(ui.text("last"))"#;
|
||||
let document = compile(source, "app.main", 1).unwrap();
|
||||
assert_eq!(document.frame.commands.len(), 1);
|
||||
assert!(
|
||||
matches!(&document.frame.commands[0], RenderCommand::Text { value, .. } if value == "last")
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn page_api_errors_and_late_failures_do_not_publish_partial_snapshots() {
|
||||
let mut state = NamespaceState::default();
|
||||
state.submission = 1;
|
||||
state
|
||||
.commit(1, compile(PAGE, "app.main", 1).unwrap())
|
||||
.unwrap();
|
||||
for source in [
|
||||
"ui.page()",
|
||||
"let title = ui.text(\"no render\")",
|
||||
"let page = ui.page(1)\npage.render(ui.text(\"x\"))",
|
||||
"let page = ui.page()\npage.render()",
|
||||
"let page = ui.page()\npage.render(\"not a node\")",
|
||||
"let page = ui.page()\npage.render(ui.text(\"partial\"))\nui.missing()",
|
||||
] {
|
||||
state.submission = state.next_submission().unwrap();
|
||||
assert!(
|
||||
compile(source, "app.main", state.submission).is_err(),
|
||||
"{source}"
|
||||
);
|
||||
assert_eq!(state.document.source, PAGE);
|
||||
assert_eq!(state.revision, 1);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn page_creation_has_a_separate_bounded_pool() {
|
||||
let mut source = String::new();
|
||||
for index in 0..=ui_bridge::MAX_PAGES {
|
||||
source.push_str(&format!("let page{index} = ui.page()\n"));
|
||||
}
|
||||
source.push_str("page0.render(ui.text(\"x\"))");
|
||||
let error = compile(&source, "app.main", 1).unwrap_err();
|
||||
assert!(error.to_string().contains("64 page budget"), "{error:#}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn script_execution_is_limited_even_without_creating_ui_nodes() {
|
||||
let mut source = "function text0(): Text { return \"Hello Endor\" }\n".to_owned();
|
||||
for index in 1..=16 {
|
||||
source.push_str(&format!(
|
||||
"function text{index}(): Text {{ let unused = text{}() return text{}() }}\n",
|
||||
index - 1,
|
||||
index - 1
|
||||
));
|
||||
}
|
||||
source.push_str("let title = ui.text(text16())\nui.page().render(title)");
|
||||
let error = compile(&source, "app.main", 1).unwrap_err();
|
||||
assert!(
|
||||
error
|
||||
.to_string()
|
||||
.contains("execution limit reached: instructions"),
|
||||
"{error:#}"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn literal_string_return_from_aster_can_be_displayed_by_the_host() {
|
||||
let source = "function main(): Text { return \"Hello Endor\" }\nlet title = ui.text(main())\nui.page().render(title)";
|
||||
let document = compile(source, "app.main", 1).unwrap();
|
||||
assert!(
|
||||
matches!(&document.frame.commands[0], RenderCommand::Text { value, .. } if value == "Hello Endor")
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn developer_selection_resets_to_the_new_source_snapshot() {
|
||||
let first = compile(PAGE, "app.main", 1).unwrap();
|
||||
let second = compile(PAGE, "app.main", 2).unwrap();
|
||||
let mut tools = crate::developer_tools::DeveloperToolsState {
|
||||
open: true,
|
||||
selected_node_id: Some(first.root.as_ref().unwrap().children[0].id.clone()),
|
||||
};
|
||||
tools.document_updated(&second);
|
||||
assert_eq!(
|
||||
tools.selected_node_id.as_deref(),
|
||||
Some(second.root.as_ref().unwrap().id.as_str())
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn executes_aster_functions_and_renders_after_vm_cleanup() {
|
||||
|
||||
@@ -0,0 +1,150 @@
|
||||
//! Feed a source snapshot to Aster's existing module or interactive entry points.
|
||||
//! Statement syntax, tokens and ASTs all remain Aster-owned. The host only batches
|
||||
//! complete interactive inputs, just as a REPL feeds consecutive inputs to a VM.
|
||||
use anyhow::Result;
|
||||
use frontend::{
|
||||
ParseMode, SourceUnit, Span, TokenKind,
|
||||
ast::{AstRoot, Decl, DeclKind, Expr, ExprKind, InteractiveInput, Stmt, StmtKind},
|
||||
};
|
||||
|
||||
pub enum SourcePlan {
|
||||
Module(AstRoot),
|
||||
Script(Vec<AstRoot>),
|
||||
}
|
||||
|
||||
impl SourcePlan {
|
||||
pub fn roots(&self) -> &[AstRoot] {
|
||||
match self {
|
||||
Self::Module(root) => std::slice::from_ref(root),
|
||||
Self::Script(roots) => roots,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn parse(source: &SourceUnit) -> Result<SourcePlan> {
|
||||
if let Ok(module) = frontend::parse_source_ast(source, ParseMode::Module) {
|
||||
return Ok(SourcePlan::Module(module));
|
||||
}
|
||||
let tokens = frontend::lex_source(source)?;
|
||||
let mut roots = Vec::new();
|
||||
let mut start = 0;
|
||||
let mut depth = 0_i64;
|
||||
for (index, token) in tokens.iter().enumerate() {
|
||||
match token.kind {
|
||||
TokenKind::LeftParen | TokenKind::LeftBrace => depth += 1,
|
||||
TokenKind::RightParen | TokenKind::RightBrace => depth -= 1,
|
||||
_ => {}
|
||||
}
|
||||
let end = token.span.end;
|
||||
let boundary = tokens.get(index + 1).is_none_or(|next| {
|
||||
depth == 0
|
||||
&& source.text()[end..next.span.start].contains(['\r', '\n'])
|
||||
&& !matches!(
|
||||
next.kind,
|
||||
TokenKind::Dot
|
||||
| TokenKind::LeftParen
|
||||
| TokenKind::Plus
|
||||
| TokenKind::Minus
|
||||
| TokenKind::Star
|
||||
| TokenKind::Slash
|
||||
)
|
||||
});
|
||||
if !boundary {
|
||||
continue;
|
||||
}
|
||||
match frontend::parse_ast(&source.text()[start..end], ParseMode::Interactive) {
|
||||
Ok(mut root) => {
|
||||
let AstRoot::Interactive(input) = &mut root else {
|
||||
unreachable!("interactive mode");
|
||||
};
|
||||
shift_input(input, start);
|
||||
roots.push(root);
|
||||
start = end;
|
||||
}
|
||||
// An incomplete interactive input can continue on the next line.
|
||||
// Only Aster decides whether its combined syntax is valid.
|
||||
Err(diagnostic) if index + 1 < tokens.len() && diagnostic.span.start == end - start => {
|
||||
}
|
||||
Err(mut diagnostic) => {
|
||||
shift_span(&mut diagnostic.span, start);
|
||||
return Err(source.annotate(diagnostic).into());
|
||||
}
|
||||
}
|
||||
}
|
||||
if roots.is_empty() {
|
||||
// Produce Aster's original empty-input diagnostic and provenance.
|
||||
frontend::parse_source_ast(source, ParseMode::Interactive)?;
|
||||
}
|
||||
Ok(SourcePlan::Script(roots))
|
||||
}
|
||||
|
||||
fn shift_span(span: &mut Span, offset: usize) {
|
||||
span.start += offset;
|
||||
span.end += offset;
|
||||
}
|
||||
|
||||
fn shift_input(input: &mut InteractiveInput, offset: usize) {
|
||||
shift_span(&mut input.span, offset);
|
||||
for statement in &mut input.statements {
|
||||
shift_statement(statement, offset);
|
||||
}
|
||||
}
|
||||
|
||||
fn shift_statement(statement: &mut Stmt, offset: usize) {
|
||||
shift_span(&mut statement.span, offset);
|
||||
match &mut statement.kind {
|
||||
StmtKind::Binding(binding) => {
|
||||
shift_span(&mut binding.span, offset);
|
||||
shift_span(&mut binding.name.span, offset);
|
||||
shift_expression(&mut binding.value, offset);
|
||||
}
|
||||
StmtKind::Return(returned) => {
|
||||
shift_span(&mut returned.span, offset);
|
||||
if let Some(expression) = &mut returned.value {
|
||||
shift_expression(expression, offset);
|
||||
}
|
||||
}
|
||||
StmtKind::Expression(expression) => shift_expression(expression, offset),
|
||||
StmtKind::Declaration(declaration) => shift_declaration(declaration, offset),
|
||||
}
|
||||
}
|
||||
|
||||
fn shift_declaration(declaration: &mut Decl, offset: usize) {
|
||||
shift_span(&mut declaration.span, offset);
|
||||
let DeclKind::Function(function) = &mut declaration.kind;
|
||||
shift_span(&mut function.span, offset);
|
||||
shift_span(&mut function.name.span, offset);
|
||||
shift_span(&mut function.return_type.span, offset);
|
||||
for parameter in &mut function.parameters {
|
||||
shift_span(&mut parameter.span, offset);
|
||||
shift_span(&mut parameter.name.span, offset);
|
||||
shift_span(&mut parameter.type_name.span, offset);
|
||||
}
|
||||
shift_span(&mut function.body.span, offset);
|
||||
for statement in &mut function.body.statements {
|
||||
shift_statement(statement, offset);
|
||||
}
|
||||
}
|
||||
|
||||
fn shift_expression(expression: &mut Expr, offset: usize) {
|
||||
shift_span(&mut expression.span, offset);
|
||||
match &mut expression.kind {
|
||||
ExprKind::Name(_) | ExprKind::Number(_) | ExprKind::String(_) => {}
|
||||
ExprKind::Symbol(name) => shift_span(&mut name.span, offset),
|
||||
ExprKind::Unary { operand, .. } => shift_expression(operand, offset),
|
||||
ExprKind::Binary { left, right, .. } => {
|
||||
shift_expression(left, offset);
|
||||
shift_expression(right, offset);
|
||||
}
|
||||
ExprKind::Member { object, name } => {
|
||||
shift_expression(object, offset);
|
||||
shift_span(&mut name.span, offset);
|
||||
}
|
||||
ExprKind::Call { callee, arguments } => {
|
||||
shift_expression(callee, offset);
|
||||
for argument in arguments {
|
||||
shift_expression(argument, offset);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -4,6 +4,7 @@ mod developer_tools;
|
||||
mod display_list;
|
||||
mod document;
|
||||
mod endor_host;
|
||||
mod endor_script;
|
||||
mod geometry;
|
||||
mod layout;
|
||||
mod scene;
|
||||
|
||||
+105
-2
@@ -12,6 +12,7 @@ use crate::document::parse_color;
|
||||
|
||||
pub const MAX_UI_NODES: usize = 4096;
|
||||
pub const MAX_UI_DEPTH: usize = 64;
|
||||
pub const MAX_PAGES: usize = 64;
|
||||
pub const MAX_DIMENSION: f64 = 1_000_000.0;
|
||||
|
||||
#[derive(Debug)]
|
||||
@@ -68,9 +69,22 @@ struct BuildSession {
|
||||
pool: Vec<(ObjectRef, UiSlot)>,
|
||||
indexes: HashMap<ObjectRef, usize>,
|
||||
used: usize,
|
||||
pages: Vec<ObjectRef>,
|
||||
pages_used: usize,
|
||||
rendered: Option<(usize, Arc<UiNode>)>,
|
||||
}
|
||||
|
||||
impl BuildSession {
|
||||
fn page(&mut self) -> Result<Value, VmError> {
|
||||
let page = self
|
||||
.pages
|
||||
.get(self.pages_used)
|
||||
.ok_or(VmError::InvalidArgument(
|
||||
"UI build exceeds the 64 page budget",
|
||||
))?;
|
||||
self.pages_used += 1;
|
||||
Ok(Value::Object(*page))
|
||||
}
|
||||
fn child(&self, value: &Value) -> Result<Arc<UiNode>, VmError> {
|
||||
let Value::Object(reference) = value else {
|
||||
return Err(VmError::InvalidArgument("UI children must be UI nodes"));
|
||||
@@ -113,6 +127,7 @@ enum Constructor {
|
||||
Column,
|
||||
Row,
|
||||
Spacer,
|
||||
Page,
|
||||
}
|
||||
|
||||
impl Constructor {
|
||||
@@ -123,6 +138,7 @@ impl Constructor {
|
||||
Self::Column => "column",
|
||||
Self::Row => "row",
|
||||
Self::Spacer => "spacer",
|
||||
Self::Page => "page",
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -148,6 +164,7 @@ impl ObjectPayload for UiConstructor {
|
||||
Constructor::Rect => (2, 4),
|
||||
Constructor::Column | Constructor::Row => (2, MAX_UI_NODES + 2),
|
||||
Constructor::Spacer => (1, 1),
|
||||
Constructor::Page => (0, 0),
|
||||
};
|
||||
if !(required..=maximum).contains(&arguments.len()) {
|
||||
return Err(VmError::ArgumentCount {
|
||||
@@ -218,11 +235,78 @@ impl ObjectPayload for UiConstructor {
|
||||
}
|
||||
}
|
||||
Constructor::Spacer => UiKind::Spacer(dimension(&arguments[0])?),
|
||||
Constructor::Page => return session.page(),
|
||||
};
|
||||
session.emit(kind)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
struct PagePayload;
|
||||
|
||||
impl ObjectPayload for PagePayload {
|
||||
fn as_any(&self) -> &dyn Any {
|
||||
self
|
||||
}
|
||||
fn kind_name(&self) -> &'static str {
|
||||
"tessera-page"
|
||||
}
|
||||
fn allows_attributes(&self) -> bool {
|
||||
true
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
struct PageRender {
|
||||
page: usize,
|
||||
session: Arc<Mutex<BuildSession>>,
|
||||
}
|
||||
|
||||
impl ObjectPayload for PageRender {
|
||||
fn as_any(&self) -> &dyn Any {
|
||||
self
|
||||
}
|
||||
fn kind_name(&self) -> &'static str {
|
||||
"tessera-page-render"
|
||||
}
|
||||
fn call(&self, arguments: &[Value]) -> Result<Value, VmError> {
|
||||
if arguments.len() != 1 {
|
||||
return Err(VmError::ArgumentCount {
|
||||
name: "page.render".into(),
|
||||
required: 1,
|
||||
maximum: 1,
|
||||
provided: arguments.len(),
|
||||
});
|
||||
}
|
||||
let mut session = self
|
||||
.session
|
||||
.lock()
|
||||
.map_err(|_| VmError::InvalidArgument("UI build session is poisoned"))?;
|
||||
if self.page >= session.pages_used {
|
||||
return Err(VmError::InvalidArgument("page is not initialized"));
|
||||
}
|
||||
let root = session.child(&arguments[0])?;
|
||||
session.rendered = Some((self.page, root));
|
||||
Ok(Value::Nil)
|
||||
}
|
||||
}
|
||||
|
||||
pub struct UiBridge {
|
||||
/// Borrowed from the candidate's external roots; never crosses VM lifetime.
|
||||
pub ui: ObjectRef,
|
||||
session: Arc<Mutex<BuildSession>>,
|
||||
}
|
||||
|
||||
impl UiBridge {
|
||||
pub fn rendered(&self) -> Result<Option<Arc<UiNode>>> {
|
||||
let session = self
|
||||
.session
|
||||
.lock()
|
||||
.map_err(|_| anyhow::anyhow!("UI build session is poisoned"))?;
|
||||
Ok(session.rendered.as_ref().map(|(_, root)| root.clone()))
|
||||
}
|
||||
}
|
||||
|
||||
fn color(value: Option<&Value>, default: &str) -> Result<String, VmError> {
|
||||
let value = match value {
|
||||
Some(Value::Text(value)) => value.as_str(),
|
||||
@@ -256,7 +340,7 @@ fn dimension(value: &Value) -> Result<f32, VmError> {
|
||||
}
|
||||
|
||||
/// All allocation roots go to the candidate, including partial installation.
|
||||
pub fn install(vm: &mut Vm, roots: &mut Vec<ObjectRef>) -> Result<ObjectRef> {
|
||||
pub fn install(vm: &mut Vm, roots: &mut Vec<ObjectRef>) -> Result<UiBridge> {
|
||||
let mut pool = Vec::with_capacity(MAX_UI_NODES);
|
||||
let mut indexes = HashMap::with_capacity(MAX_UI_NODES);
|
||||
for index in 0..MAX_UI_NODES {
|
||||
@@ -270,7 +354,25 @@ pub fn install(vm: &mut Vm, roots: &mut Vec<ObjectRef>) -> Result<ObjectRef> {
|
||||
pool,
|
||||
indexes,
|
||||
used: 0,
|
||||
pages: Vec::with_capacity(MAX_PAGES),
|
||||
pages_used: 0,
|
||||
rendered: None,
|
||||
}));
|
||||
for page in 0..MAX_PAGES {
|
||||
let reference = vm.allocate(PagePayload)?;
|
||||
roots.push(reference);
|
||||
let render = vm.allocate(PageRender {
|
||||
page,
|
||||
session: session.clone(),
|
||||
})?;
|
||||
roots.push(render);
|
||||
vm.set_attr(reference, "render", Value::Object(render))?;
|
||||
session
|
||||
.lock()
|
||||
.map_err(|_| anyhow::anyhow!("UI build session is poisoned"))?
|
||||
.pages
|
||||
.push(reference);
|
||||
}
|
||||
let ui = vm.new_object()?;
|
||||
roots.push(ui);
|
||||
for constructor in [
|
||||
@@ -279,6 +381,7 @@ pub fn install(vm: &mut Vm, roots: &mut Vec<ObjectRef>) -> Result<ObjectRef> {
|
||||
Constructor::Column,
|
||||
Constructor::Row,
|
||||
Constructor::Spacer,
|
||||
Constructor::Page,
|
||||
] {
|
||||
let function = vm.allocate(UiConstructor {
|
||||
constructor,
|
||||
@@ -287,7 +390,7 @@ pub fn install(vm: &mut Vm, roots: &mut Vec<ObjectRef>) -> Result<ObjectRef> {
|
||||
roots.push(function);
|
||||
vm.set_attr(ui, constructor.name(), Value::Object(function))?;
|
||||
}
|
||||
Ok(ui)
|
||||
Ok(UiBridge { ui, session })
|
||||
}
|
||||
|
||||
pub fn snapshot(vm: &Vm, result: &Value) -> Result<Arc<UiNode>> {
|
||||
|
||||
Reference in New Issue
Block a user