coop/rose-ash
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Phase 7b: page render plans — per-page boundary optimizer

Browse Source 
Add page-render-plan to deps.sx: given page source + env + IO names,
computes a dict mapping each needed component to "server" or "client",
with server/client lists and IO dep collection. 5 new spec tests.

Integration:
- PageDef.render_plan field caches the plan at registration
- compute_page_render_plans() called from auto_mount_pages()
- Client page registry includes :render-plan per page
- Affinity demo page shows per-page render plans

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
giles
2026-03-08 00:02:53 +00:00
parent a70ff2b153
commit 2da80c69ed
14 changed files with 214 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
shared/static/scripts/sx-browser.js
View File

@@ -14,7 +14,7 @@
// =========================================================================
var NIL = Object.freeze({ _nil: true, toString: function() { return "nil"; } });
var SX_VERSION = "2026-03-07T23:47:29Z";
var SX_VERSION = "2026-03-07T23:59:03Z";
function isNil(x) { return x === NIL || x === null || x === undefined; }
function isSxTruthy(x) { return x !== false && !isNil(x); }

16
shared/sx/deps.py
View File

@@ -198,6 +198,22 @@ def compute_all_io_refs(env: dict[str, Any], io_names: set[str]) -> None:
_compute_all_io_refs_fallback(env, io_names)
def page_render_plan(page_sx: str, env: dict[str, Any], io_names: set[str] | None = None) -> dict[str, Any]:
"""Compute the render plan for a page.
Returns dict with:
- "components": {name: "server"|"client", ...}
- "server": [names rendered server-side]
- "client": [names rendered client-side]
- "io-deps": [IO primitive names needed by server components]
"""
if io_names is None:
io_names = get_all_io_names()
from .ref.sx_ref import page_render_plan as _ref_prp
plan = _ref_prp(page_sx, env, list(io_names))
return plan
def get_all_io_names() -> set[str]:
"""Build the complete set of IO primitive names from all boundary tiers.

10
shared/sx/helpers.py
View File

@@ -738,6 +738,15 @@ def _build_pages_sx(service: str) -> str:
stream = "true" if page_def.stream else "false"
# Render plan: which components render where
plan = page_def.render_plan
if plan:
server_sx = "(" + " ".join(_sx_literal(n) for n in plan.get("server", [])) + ")"
client_sx = "(" + " ".join(_sx_literal(n) for n in plan.get("client", [])) + ")"
render_plan_sx = "{:server " + server_sx + " :client " + client_sx + "}"
else:
render_plan_sx = "{:server () :client ()}"
entry = (
"{:name " + _sx_literal(page_def.name)
+ " :path " + _sx_literal(page_def.path)
@@ -746,6 +755,7 @@ def _build_pages_sx(service: str) -> str:
+ " :stream " + stream
+ " :layout " + _sx_literal(layout_id)
+ " :io-deps " + io_deps_sx
+ " :render-plan " + render_plan_sx
+ " :content " + _sx_literal(content_src)
+ " :deps " + deps_sx
+ " :closure " + closure_sx + "}"

23
shared/sx/pages.py
View File

@@ -840,6 +840,25 @@ async def execute_page_streaming_oob(
# Blueprint mounting
# ---------------------------------------------------------------------------
def compute_page_render_plans(service_name: str) -> None:
"""Pre-compute and cache render plans for all pages in a service.
Must be called after components are loaded (compute_all_deps/io_refs done)
and pages are registered. Stores plans on PageDef.render_plan.
"""
from .parser import serialize
from .deps import page_render_plan, get_all_io_names
from .jinja_bridge import _COMPONENT_ENV
io_names = get_all_io_names()
pages = get_all_pages(service_name)
for page_def in pages.values():
if page_def.content_expr is not None:
content_src = serialize(page_def.content_expr)
page_def.render_plan = page_render_plan(content_src, _COMPONENT_ENV, io_names)
logger.info("Computed render plans for %d pages in %s", len(pages), service_name)
def auto_mount_pages(app: Any, service_name: str) -> None:
"""Auto-mount all registered defpages for a service directly on the app.
@@ -849,6 +868,10 @@ def auto_mount_pages(app: Any, service_name: str) -> None:
Also mounts the /sx/data/ endpoint for client-side data fetching.
"""
pages = get_all_pages(service_name)
# Pre-compute render plans (which components render where)
compute_page_render_plans(service_name)
for page_def in pages.values():
_mount_one_page(app, service_name, page_def)
logger.info("Auto-mounted %d defpages for %s", len(pages), service_name)

1
shared/sx/ref/bootstrap_js.py
View File

@@ -549,6 +549,7 @@ class JSEmitter:
"compute-all-io-refs": "computeAllIoRefs",
"component-pure?": "componentPure_p",
"render-target": "renderTarget",
"page-render-plan": "pageRenderPlan",
# router.sx
"split-path-segments": "splitPathSegments",
"make-route-segment": "makeRouteSegment",

1
shared/sx/ref/bootstrap_py.py
View File

@@ -278,6 +278,7 @@ class PyEmitter:
"compute-all-io-refs": "compute_all_io_refs",
"component-pure?": "component_pure_p",
"render-target": "render_target",
"page-render-plan": "page_render_plan",
# router.sx
"split-path-segments": "split_path_segments",
"make-route-segment": "make_route_segment",

44
shared/sx/ref/deps.sx
View File

@@ -341,6 +341,50 @@
:else "client")))))))
;; --------------------------------------------------------------------------
;; 6. Page render plan — pre-computed boundary decisions for a page
;; --------------------------------------------------------------------------
;; Given page source + env + IO names, returns a render plan dict:
;;
;; {:components {~name "server"|"client" ...}
;; :server (list of ~names that render server-side)
;; :client (list of ~names that render client-side)
;; :io-deps (list of IO primitives needed by server components)}
;;
;; This is computed once at page registration and cached on the page def.
;; The async evaluator and client router both use it to make decisions
;; without recomputing at every request.
(define page-render-plan
(fn (page-source env io-names)
(let ((needed (components-needed page-source env))
(comp-targets (dict))
(server-list (list))
(client-list (list))
(io-deps (list)))
(for-each
(fn (name)
(let ((target (render-target name env io-names)))
(dict-set! comp-targets name target)
(if (= target "server")
(do
(append! server-list name)
;; Collect IO deps from server components
(for-each
(fn (io-ref)
(when (not (contains? io-deps io-ref))
(append! io-deps io-ref)))
(transitive-io-refs name env io-names)))
(append! client-list name))))
needed)
{:components comp-targets
:server server-list
:client client-list
:io-deps io-deps})))
;; --------------------------------------------------------------------------
;; Host obligation: selective expansion in async partial evaluation
;; --------------------------------------------------------------------------

3
shared/sx/ref/sx_ref.py
View File

@@ -1301,6 +1301,9 @@ component_pure_p = lambda name, env, io_names: empty_p(transitive_io_refs(name,
# render-target
render_target = lambda name, env, io_names: (lambda key: (lambda val: ('server' if sx_truthy((not sx_truthy((type_of(val) == 'component')))) else (lambda affinity: ('server' if sx_truthy((affinity == 'server')) else ('client' if sx_truthy((affinity == 'client')) else ('server' if sx_truthy((not sx_truthy(component_pure_p(name, env, io_names)))) else 'client'))))(component_affinity(val))))(env_get(env, key)))((name if sx_truthy(starts_with_p(name, '~')) else sx_str('~', name)))
# page-render-plan
page_render_plan = lambda page_source, env, io_names: (lambda needed: (lambda comp_targets: (lambda server_list: (lambda client_list: (lambda io_deps: _sx_begin(for_each(lambda name: (lambda target: _sx_begin(_sx_dict_set(comp_targets, name, target), (_sx_begin(_sx_append(server_list, name), for_each(lambda io_ref: (_sx_append(io_deps, io_ref) if sx_truthy((not sx_truthy(contains_p(io_deps, io_ref)))) else NIL), transitive_io_refs(name, env, io_names))) if sx_truthy((target == 'server')) else _sx_append(client_list, name))))(render_target(name, env, io_names)), needed), {'components': comp_targets, 'server': server_list, 'client': client_list, 'io-deps': io_deps}))([]))([]))([]))({}))(components_needed(page_source, env))
# =========================================================================
# Fixups -- wire up render adapter dispatch

40
shared/sx/ref/test-deps.sx
View File

@@ -263,3 +263,43 @@
(deftest "unknown name targets server"
(assert-equal "server" (render-target "~nonexistent" (test-env) (list "fetch-data")))))
;; --------------------------------------------------------------------------
;; 7. page-render-plan — per-page boundary plan
;; --------------------------------------------------------------------------
;; A page component that uses both pure and IO components
(defcomp ~plan-page (&key data)
(div
(~dep-auto-pure :x "hello")
(~dep-auto-io :x data)
(~dep-force-client :x "interactive")))
(defsuite "page-render-plan"
(deftest "plan classifies components correctly"
(let ((plan (page-render-plan "(~plan-page :data d)" (test-env) (list "fetch-data"))))
;; ~plan-page has transitive IO deps (via ~dep-auto-io) so targets server
(assert-equal "server" (dict-get (get plan :components) "~plan-page"))
(assert-equal "client" (dict-get (get plan :components) "~dep-auto-pure"))
(assert-equal "server" (dict-get (get plan :components) "~dep-auto-io"))
(assert-equal "client" (dict-get (get plan :components) "~dep-force-client"))))
(deftest "plan server list contains IO components"
(let ((plan (page-render-plan "(~plan-page :data d)" (test-env) (list "fetch-data"))))
(assert-true (contains? (get plan :server) "~dep-auto-io"))))
(deftest "plan client list contains pure components"
(let ((plan (page-render-plan "(~plan-page :data d)" (test-env) (list "fetch-data"))))
(assert-true (contains? (get plan :client) "~dep-auto-pure"))
(assert-true (contains? (get plan :client) "~dep-force-client"))))
(deftest "plan collects IO deps from server components"
(let ((plan (page-render-plan "(~plan-page :data d)" (test-env) (list "fetch-data"))))
(assert-true (contains? (get plan :io-deps) "fetch-data"))))
(deftest "pure-only page has empty server list"
(let ((plan (page-render-plan "(~dep-auto-pure :x 1)" (test-env) (list "fetch-data"))))
(assert-equal 0 (len (get plan :server)))
(assert-true (> (len (get plan :client)) 0)))))

2
shared/sx/tests/run.py
View File

@@ -289,6 +289,7 @@ def _load_deps_from_bootstrap(env):
compute_all_io_refs,
component_pure_p,
render_target,
page_render_plan,
)
env["scan-refs"] = scan_refs
env["scan-components-from-source"] = scan_components_from_source
@@ -302,6 +303,7 @@ def _load_deps_from_bootstrap(env):
env["compute-all-io-refs"] = compute_all_io_refs
env["component-pure?"] = component_pure_p
env["render-target"] = render_target
env["page-render-plan"] = page_render_plan
env["test-env"] = lambda: env
except ImportError:
eval_file("deps.sx", env)

1
shared/sx/types.py
View File

@@ -255,6 +255,7 @@ class PageDef:
fallback_expr: Any = None # fallback content while streaming
shell_expr: Any = None # immediate shell content (wraps suspense)
closure: dict[str, Any] = field(default_factory=dict)
render_plan: dict[str, Any] | None = field(default=None, repr=False)
_FIELD_MAP = {
"name": "name", "path": "path", "auth": "auth",