@stacksjs/stx 0.2.572 → 0.2.573

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (381) hide show
  1. package/dist/a11y.d.ts +51 -111
  2. package/dist/animation.d.ts +131 -74
  3. package/dist/api-client.d.ts +11 -21
  4. package/dist/api-handler.d.ts +4 -4
  5. package/dist/appearance-bootstrap.d.ts +16 -77
  6. package/dist/application-layers.d.ts +11 -20
  7. package/dist/asset-roots.d.ts +7 -27
  8. package/dist/assets.d.ts +7 -9
  9. package/dist/async-components.d.ts +56 -78
  10. package/dist/auth.d.ts +0 -3
  11. package/dist/browser-core-imports.d.ts +2 -2
  12. package/dist/build-externalize-repeated.d.ts +0 -25
  13. package/dist/build-externalize.d.ts +18 -53
  14. package/dist/build-id.d.ts +40 -28
  15. package/dist/build-message.d.ts +20 -44
  16. package/dist/builtins/attrs.d.ts +0 -14
  17. package/dist/builtins/drawer.d.ts +3 -22
  18. package/dist/builtins/icon.d.ts +17 -19
  19. package/dist/builtins/image-alpha.d.ts +8 -8
  20. package/dist/builtins/image-delivery.d.ts +38 -40
  21. package/dist/builtins/image-placeholder.d.ts +12 -50
  22. package/dist/builtins/image-warmup-worker.d.ts +1 -1
  23. package/dist/builtins/image-worker.d.ts +6 -32
  24. package/dist/builtins/index.d.ts +16 -6
  25. package/dist/builtins/modal.d.ts +13 -23
  26. package/dist/builtins/safe-image.d.ts +2 -42
  27. package/dist/builtins/stx-image.d.ts +44 -24
  28. package/dist/builtins/stx-link.d.ts +5 -8
  29. package/dist/builtins/stx-loading-indicator.d.ts +11 -10
  30. package/dist/builtins/suspense.d.ts +6 -27
  31. package/dist/builtins/toast.d.ts +15 -16
  32. package/dist/builtins/transition-group.d.ts +1 -25
  33. package/dist/caching.d.ts +24 -21
  34. package/dist/{chunk-f4jh9vrj.js → chunk-0s647d0b.js} +53 -53
  35. package/dist/{chunk-09gtbb1w.js → chunk-1bsafdnt.js} +1 -1
  36. package/dist/{chunk-m6mxqepz.js → chunk-1btr5tme.js} +1 -1
  37. package/dist/{chunk-01mxer9s.js → chunk-2g6wcnna.js} +1 -1
  38. package/dist/{chunk-rrj5m9xv.js → chunk-2hg2bqtj.js} +1 -1
  39. package/dist/{chunk-xckzvbvn.js → chunk-4f0fh2a9.js} +1 -1
  40. package/dist/chunk-557wtdps.js +2 -0
  41. package/dist/{chunk-vr36s2en.js → chunk-58vrf6kh.js} +1 -1
  42. package/dist/{chunk-qzbzn1yf.js → chunk-6tsnz28m.js} +1 -1
  43. package/dist/{chunk-cvswrbzw.js → chunk-6x8cwscv.js} +1 -1
  44. package/dist/{chunk-1n64749x.js → chunk-74ew8ajw.js} +1 -1
  45. package/dist/{chunk-jqefcghh.js → chunk-78d6yyxz.js} +2 -2
  46. package/dist/{chunk-83fdt4yj.js → chunk-824cnbac.js} +1 -1
  47. package/dist/{chunk-ntgy4e1q.js → chunk-864xm0jy.js} +1 -1
  48. package/dist/{chunk-nn174xjh.js → chunk-9fbkdrm8.js} +1 -1
  49. package/dist/{chunk-kzjrgh0b.js → chunk-a3gvw1q2.js} +1 -1
  50. package/dist/{chunk-pqcvh9pp.js → chunk-amtrg7pn.js} +1 -1
  51. package/dist/{chunk-pw9verqx.js → chunk-b5fpsp5n.js} +1 -1
  52. package/dist/{chunk-5afw7z6v.js → chunk-bcjr3fw7.js} +1 -1
  53. package/dist/{chunk-n6qp05t9.js → chunk-bkj0j5se.js} +1 -1
  54. package/dist/{chunk-mzqyv7s5.js → chunk-cf97xdqa.js} +1 -1
  55. package/dist/{chunk-cgwyd9aq.js → chunk-cr67dpx4.js} +1 -1
  56. package/dist/{chunk-f1apaqfk.js → chunk-dpqvacd1.js} +1 -1
  57. package/dist/{chunk-ghy82tsc.js → chunk-et8726at.js} +1 -1
  58. package/dist/{chunk-4bgfpkwx.js → chunk-ev8t5cxk.js} +1 -1
  59. package/dist/{chunk-s34g3awk.js → chunk-fynh3bkq.js} +1 -1
  60. package/dist/{chunk-gzgc8zk5.js → chunk-g8757f97.js} +2 -2
  61. package/dist/{chunk-3gft8zng.js → chunk-hm4j4d8q.js} +1 -1
  62. package/dist/{chunk-0bt0fbs1.js → chunk-j9qy9t3t.js} +5 -5
  63. package/dist/{chunk-2a1q5y6r.js → chunk-jhc47xzj.js} +1 -1
  64. package/dist/{chunk-79vdkvhf.js → chunk-kns5m52j.js} +1 -1
  65. package/dist/{chunk-2cqbyb8w.js → chunk-mjpewk4r.js} +1 -1
  66. package/dist/{chunk-2jjff8kv.js → chunk-nj488tj2.js} +2 -2
  67. package/dist/{chunk-dcpf6kas.js → chunk-q9chv68c.js} +1 -1
  68. package/dist/{chunk-xq2ck69k.js → chunk-qm280dp3.js} +1 -1
  69. package/dist/{chunk-ymawe0y5.js → chunk-sjcstv33.js} +1 -1
  70. package/dist/{chunk-tc5r2vmw.js → chunk-t0zdz8kd.js} +1 -1
  71. package/dist/{chunk-jwvzvapp.js → chunk-t3dnak1j.js} +1 -1
  72. package/dist/{chunk-2jsnrfc8.js → chunk-t64nnmmj.js} +1 -1
  73. package/dist/{chunk-m2a1fxpb.js → chunk-tvb8p7c0.js} +1 -1
  74. package/dist/{chunk-6f4qrd0s.js → chunk-tyhgq6rw.js} +1 -1
  75. package/dist/{chunk-4wfr074d.js → chunk-vn7tc8hm.js} +1 -1
  76. package/dist/{chunk-y4ajd836.js → chunk-xy6g8zb9.js} +1 -1
  77. package/dist/{chunk-zddzjd60.js → chunk-ya7xks9t.js} +1 -1
  78. package/dist/chunk-zpz6q2fh.js +2 -0
  79. package/dist/chunk-zxt94g45.js +2 -0
  80. package/dist/{chunk-cyg9w31a.js → chunk-zz7tw07b.js} +1 -1
  81. package/dist/{chunk-ta8bhz27.js → chunk-zzcxacjf.js} +1 -1
  82. package/dist/cli.js +7 -7
  83. package/dist/client/directive.d.ts +0 -7
  84. package/dist/client/index.d.ts +1 -0
  85. package/dist/client/signals-appearance-runtime.d.ts +1 -1
  86. package/dist/client/signals-binding-utils-runtime.d.ts +1 -1
  87. package/dist/client/signals-bootstrap-runtime.d.ts +2 -2
  88. package/dist/client/signals-class-runtime.d.ts +1 -1
  89. package/dist/client/signals-component-api-runtime.d.ts +1 -1
  90. package/dist/client/signals-component-hydration-runtime.d.ts +1 -1
  91. package/dist/client/signals-component-props-runtime.d.ts +1 -1
  92. package/dist/client/signals-conditional-chain-runtime.d.ts +1 -1
  93. package/dist/client/signals-conditional-component-runtime.d.ts +1 -1
  94. package/dist/client/signals-container-cleanup-runtime.d.ts +1 -1
  95. package/dist/client/signals-context-runtime.d.ts +1 -1
  96. package/dist/client/signals-cookie-runtime.d.ts +1 -1
  97. package/dist/client/signals-devtools-runtime.d.ts +1 -1
  98. package/dist/client/signals-dialog-runtime.d.ts +1 -1
  99. package/dist/client/signals-dom-ready-runtime.d.ts +1 -1
  100. package/dist/client/signals-drawer-runtime.d.ts +1 -1
  101. package/dist/client/signals-effect-runtime.d.ts +1 -1
  102. package/dist/client/signals-event-shorthand-runtime.d.ts +1 -1
  103. package/dist/client/signals-expression-compiler-runtime.d.ts +1 -1
  104. package/dist/client/signals-expression-runtime.d.ts +1 -1
  105. package/dist/client/signals-fetch-transport-runtime.d.ts +1 -1
  106. package/dist/client/signals-for-runtime.d.ts +1 -1
  107. package/dist/client/signals-globals-runtime.d.ts +1 -1
  108. package/dist/client/signals-handler-runtime.d.ts +1 -1
  109. package/dist/client/signals-head-runtime.d.ts +1 -1
  110. package/dist/client/signals-helpers-runtime.d.ts +1 -1
  111. package/dist/client/signals-host-runtime.d.ts +1 -1
  112. package/dist/client/signals-hydration-audit-runtime.d.ts +1 -1
  113. package/dist/client/signals-hydration-runtime.d.ts +1 -1
  114. package/dist/client/signals-if-chain-runtime.d.ts +1 -1
  115. package/dist/client/signals-if-runtime.d.ts +1 -1
  116. package/dist/client/signals-lazy-hydration-runtime.d.ts +1 -1
  117. package/dist/client/signals-lifecycle-runtime.d.ts +1 -1
  118. package/dist/client/signals-loop-component-remap-runtime.d.ts +1 -1
  119. package/dist/client/signals-loop-conditional-runtime.d.ts +1 -1
  120. package/dist/client/signals-loop-row-runtime.d.ts +1 -1
  121. package/dist/client/signals-manifest-hydration-runtime.d.ts +1 -1
  122. package/dist/client/signals-model-runtime.d.ts +1 -1
  123. package/dist/client/signals-mount-runtime.d.ts +1 -1
  124. package/dist/client/signals-navigation-runtime.d.ts +1 -1
  125. package/dist/client/signals-notify-runtime.d.ts +1 -1
  126. package/dist/client/signals-optimistic-runtime.d.ts +1 -1
  127. package/dist/client/signals-overlay-runtime.d.ts +1 -1
  128. package/dist/client/signals-pipe-runtime.d.ts +1 -1
  129. package/dist/client/signals-proxy-runtime.d.ts +1 -1
  130. package/dist/client/signals-query-runtime.d.ts +1 -1
  131. package/dist/client/signals-reactive-runtime.d.ts +1 -1
  132. package/dist/client/signals-ref-runtime.d.ts +1 -1
  133. package/dist/client/signals-scope-disposal-runtime.d.ts +1 -1
  134. package/dist/client/signals-scope-traversal-runtime.d.ts +1 -1
  135. package/dist/client/signals-show-runtime.d.ts +1 -1
  136. package/dist/client/signals-spa-load-control-runtime.d.ts +1 -1
  137. package/dist/client/signals-spa-load-runtime.d.ts +1 -1
  138. package/dist/client/signals-state-runtime.d.ts +1 -1
  139. package/dist/client/signals-storage-runtime.d.ts +1 -1
  140. package/dist/client/signals-store-registry-runtime.d.ts +1 -1
  141. package/dist/client/signals-style-runtime.d.ts +1 -1
  142. package/dist/client/signals-suspense-runtime.d.ts +1 -1
  143. package/dist/client/signals-timer-runtime.d.ts +1 -1
  144. package/dist/client/signals-toast-runtime.d.ts +1 -1
  145. package/dist/client/signals-tooltip-runtime.d.ts +1 -1
  146. package/dist/client/signals-transition-group-runtime.d.ts +1 -1
  147. package/dist/client/signals-websocket-runtime.d.ts +1 -1
  148. package/dist/client-helpers.d.ts +1 -312
  149. package/dist/client-module-registry.d.ts +4 -27
  150. package/dist/client-parameter-bindings.d.ts +1 -4
  151. package/dist/client-script-bundler.d.ts +55 -103
  152. package/dist/client-script.d.ts +69 -127
  153. package/dist/color-mode-boot.d.ts +21 -58
  154. package/dist/component-client-factories.d.ts +8 -9
  155. package/dist/component-contract-checks.d.ts +15 -18
  156. package/dist/component-contract.d.ts +6 -6
  157. package/dist/component-hmr.d.ts +8 -7
  158. package/dist/component-model.d.ts +14 -20
  159. package/dist/component-processing.d.ts +51 -59
  160. package/dist/component-registry.d.ts +28 -99
  161. package/dist/component-renderer.d.ts +19 -16
  162. package/dist/component-resolution.d.ts +8 -8
  163. package/dist/component-tags.d.ts +1 -1
  164. package/dist/composable-loader.d.ts +6 -41
  165. package/dist/composables/use-fetch.d.ts +45 -114
  166. package/dist/composables/use-form.d.ts +2 -56
  167. package/dist/composables/use-intersection-observer.d.ts +1 -1
  168. package/dist/composables.d.ts +75 -74
  169. package/dist/composition-api.d.ts +19 -43
  170. package/dist/computed.d.ts +93 -86
  171. package/dist/conditionals.d.ts +0 -24
  172. package/dist/config.d.ts +30 -24
  173. package/dist/config.js +3 -0
  174. package/dist/craft-bridge.d.ts +1 -467
  175. package/dist/craft-components.d.ts +234 -680
  176. package/dist/craft-entry.js +1 -1
  177. package/dist/craft.js +1 -1
  178. package/dist/csp.d.ts +41 -107
  179. package/dist/database.d.ts +1 -1
  180. package/dist/defer.d.ts +0 -24
  181. package/dist/dev-server/terminal-colors.d.ts +32 -32
  182. package/dist/dev-server/ts-css.d.ts +26 -35
  183. package/dist/dev-server/types.d.ts +33 -29
  184. package/dist/directive-api.d.ts +42 -85
  185. package/dist/directive-arguments.d.ts +14 -39
  186. package/dist/document-shell.d.ts +49 -81
  187. package/dist/dynamic-components.d.ts +0 -9
  188. package/dist/engine-bindings.d.ts +1 -1
  189. package/dist/env.d.ts +26 -0
  190. package/dist/error-boundaries.d.ts +36 -43
  191. package/dist/error-handling.d.ts +1 -1
  192. package/dist/errors/codes.d.ts +43 -51
  193. package/dist/errors/formatter.d.ts +38 -58
  194. package/dist/errors/index.d.ts +61 -5
  195. package/dist/errors/logger.d.ts +40 -114
  196. package/dist/errors/sanitizer.d.ts +28 -53
  197. package/dist/errors/types.d.ts +31 -44
  198. package/dist/events.d.ts +32 -94
  199. package/dist/expressions.d.ts +57 -62
  200. package/dist/find-body-tag.d.ts +5 -34
  201. package/dist/first-script-tag.d.ts +0 -23
  202. package/dist/forms-validation.d.ts +117 -149
  203. package/dist/forms.d.ts +161 -120
  204. package/dist/framework-composables.d.ts +0 -32
  205. package/dist/head-injection.d.ts +30 -32
  206. package/dist/head-keys.d.ts +12 -15
  207. package/dist/head.d.ts +110 -139
  208. package/dist/heatmap.d.ts +76 -152
  209. package/dist/html-masking.d.ts +38 -62
  210. package/dist/hydration-runtime.d.ts +24 -20
  211. package/dist/hydration.d.ts +11 -10
  212. package/dist/i18n.d.ts +34 -95
  213. package/dist/image-optimization/auto-sibling.d.ts +4 -32
  214. package/dist/imported-signals.d.ts +0 -36
  215. package/dist/includes.d.ts +6 -69
  216. package/dist/index.d.ts +2 -1
  217. package/dist/init.d.ts +12 -20
  218. package/dist/internal-markdown.d.ts +8 -12
  219. package/dist/interpolation-context.d.ts +15 -15
  220. package/dist/island-chunking.d.ts +13 -30
  221. package/dist/keep-alive.d.ts +52 -72
  222. package/dist/layout-types.d.ts +2 -27
  223. package/dist/lazy-module.d.ts +0 -10
  224. package/dist/loading-indicator.d.ts +8 -5
  225. package/dist/loop-binding.d.ts +4 -7
  226. package/dist/loops.d.ts +25 -67
  227. package/dist/markdown.d.ts +1 -0
  228. package/dist/media/image/component.d.ts +9 -25
  229. package/dist/media/image/directive.d.ts +1 -15
  230. package/dist/media/image/placeholder.d.ts +9 -20
  231. package/dist/media/image/processor/cache.d.ts +18 -40
  232. package/dist/media/image/processor/index.d.ts +10 -1
  233. package/dist/media/image/processor/optimizer.d.ts +1 -12
  234. package/dist/media/image/processor/responsive.d.ts +6 -16
  235. package/dist/media/image/srcset.d.ts +49 -47
  236. package/dist/media/shared/cache.d.ts +31 -51
  237. package/dist/media/shared/hash.d.ts +0 -7
  238. package/dist/media/types.d.ts +754 -1235
  239. package/dist/media/video/directive.d.ts +1 -15
  240. package/dist/media/video/index.d.ts +17 -39
  241. package/dist/media/video/processor/cache.d.ts +19 -42
  242. package/dist/media/video/processor/index.d.ts +18 -1
  243. package/dist/media/video/processor/streaming.d.ts +10 -17
  244. package/dist/media/video/processor/thumbnail.d.ts +15 -21
  245. package/dist/media/video/processor/transcoder.d.ts +1 -11
  246. package/dist/meta-arguments.d.ts +14 -39
  247. package/dist/method-spoofing.d.ts +0 -7
  248. package/dist/middleware.d.ts +0 -60
  249. package/dist/native/bridge/protocol.d.ts +2 -1
  250. package/dist/native/compiler/headwind-to-style.d.ts +383 -359
  251. package/dist/native/compiler/icons.d.ts +249 -243
  252. package/dist/native/compiler/svg.d.ts +35 -24
  253. package/dist/native/runtime/jsc-globals.d.ts +1 -1
  254. package/dist/native/runtime/native-host.d.ts +1 -1
  255. package/dist/native/runtime/native-host.js +3 -0
  256. package/dist/offline/app-service-worker.d.ts +50 -114
  257. package/dist/offline/kept-store.d.ts +23 -37
  258. package/dist/offline/query-cache.d.ts +55 -126
  259. package/dist/owned-routes.d.ts +0 -31
  260. package/dist/page-response.d.ts +8 -39
  261. package/dist/parser/directive-parser.d.ts +45 -57
  262. package/dist/parser/expression-parser.d.ts +35 -33
  263. package/dist/parser/index.d.ts +39 -4
  264. package/dist/parser/tokenizer.d.ts +49 -61
  265. package/dist/partial-hydration.d.ts +51 -82
  266. package/dist/performance-utils.d.ts +115 -255
  267. package/dist/placeholder.d.ts +9 -18
  268. package/dist/plugin-system.d.ts +115 -264
  269. package/dist/process.d.ts +4 -9
  270. package/dist/process.js +6 -4
  271. package/dist/prop-sentinels.d.ts +11 -11
  272. package/dist/public-env.d.ts +0 -14
  273. package/dist/pwa/directives.d.ts +20 -12
  274. package/dist/pwa/inject.d.ts +0 -10
  275. package/dist/pwa/precache.d.ts +16 -22
  276. package/dist/pwa/service-worker.d.ts +0 -12
  277. package/dist/pwa.js +1 -1
  278. package/dist/reactive-bindings.d.ts +11 -34
  279. package/dist/reactive-tracking.d.ts +0 -36
  280. package/dist/reactive.d.ts +41 -58
  281. package/dist/render-memo.d.ts +5 -23
  282. package/dist/resolve-stx-targets.d.ts +6 -44
  283. package/dist/route-middleware.d.ts +35 -2
  284. package/dist/route-rules.d.ts +10 -13
  285. package/dist/router.d.ts +9 -8
  286. package/dist/routes.d.ts +3 -1
  287. package/dist/runtime-config-server.d.ts +14 -17
  288. package/dist/runtime-config.d.ts +2 -3
  289. package/dist/runtime-globals.d.ts +90 -122
  290. package/dist/runtime-injection.d.ts +0 -8
  291. package/dist/scaffolding.d.ts +30 -26
  292. package/dist/script-emit.d.ts +0 -30
  293. package/dist/script-validation.d.ts +6 -12
  294. package/dist/seo.d.ts +75 -153
  295. package/dist/server-api.d.ts +9 -12
  296. package/dist/server-bindings.d.ts +1 -26
  297. package/dist/server-data.d.ts +4 -5
  298. package/dist/sfc-template.d.ts +8 -8
  299. package/dist/signal-processing.d.ts +37 -53
  300. package/dist/signals-api.d.ts +58 -135
  301. package/dist/signals.d.ts +18 -24
  302. package/dist/site-url.d.ts +31 -28
  303. package/dist/slots.d.ts +20 -86
  304. package/dist/source-signature.d.ts +5 -28
  305. package/dist/ssg.d.ts +158 -337
  306. package/dist/ssg.js +2 -2
  307. package/dist/state-dir.d.ts +4 -4
  308. package/dist/store-loader.d.ts +0 -10
  309. package/dist/story/analytics.d.ts +60 -138
  310. package/dist/story/bookmarks.d.ts +34 -87
  311. package/dist/story/cli.d.ts +69 -123
  312. package/dist/story/collect/scanner.d.ts +0 -4
  313. package/dist/story/collect/tree.d.ts +1 -8
  314. package/dist/story/commands/build.d.ts +6 -11
  315. package/dist/story/commands/dev.d.ts +8 -15
  316. package/dist/story/commands/preview.d.ts +7 -13
  317. package/dist/story/config-watcher.d.ts +13 -20
  318. package/dist/story/config.d.ts +8 -11
  319. package/dist/story/context.d.ts +8 -14
  320. package/dist/story/hmr.d.ts +26 -24
  321. package/dist/story/hot-swap.d.ts +23 -34
  322. package/dist/story/keyboard-shortcuts.d.ts +18 -23
  323. package/dist/story/output.d.ts +44 -46
  324. package/dist/story/performance.d.ts +45 -107
  325. package/dist/story/presets.d.ts +41 -107
  326. package/dist/story/renderer.d.ts +27 -41
  327. package/dist/story/search.d.ts +12 -23
  328. package/dist/story/server.d.ts +11 -21
  329. package/dist/story/setup.d.ts +15 -23
  330. package/dist/story/testing.d.ts +40 -65
  331. package/dist/story/types.d.ts +160 -262
  332. package/dist/streaming.d.ts +57 -119
  333. package/dist/strip-literals.d.ts +1 -25
  334. package/dist/stx-module-imports.d.ts +7 -0
  335. package/dist/stx-virtual-ts.d.ts +102 -253
  336. package/dist/style-scoping.d.ts +8 -21
  337. package/dist/suspense.d.ts +52 -67
  338. package/dist/teleport.d.ts +0 -22
  339. package/dist/template-syntax-escape.d.ts +8 -8
  340. package/dist/template-tag-balance.d.ts +6 -22
  341. package/dist/testing.d.ts +26 -11
  342. package/dist/theme-tokens.d.ts +388 -134
  343. package/dist/transitions.d.ts +55 -66
  344. package/dist/ts-css-config.d.ts +12 -70
  345. package/dist/types/component-types.d.ts +122 -187
  346. package/dist/types/config-types.d.ts +341 -956
  347. package/dist/types/context-types.d.ts +24 -46
  348. package/dist/types/csp-types.d.ts +66 -70
  349. package/dist/types/directive-types.d.ts +156 -223
  350. package/dist/types/index.d.ts +110 -6
  351. package/dist/types/pwa-types.d.ts +148 -273
  352. package/dist/types.d.ts +1 -0
  353. package/dist/unresolved-identifiers.d.ts +22 -24
  354. package/dist/url-safety.d.ts +32 -32
  355. package/dist/utils.d.ts +21 -36
  356. package/dist/validator.d.ts +26 -28
  357. package/dist/variable-extractor.d.ts +19 -49
  358. package/dist/view-composers.d.ts +81 -80
  359. package/dist/virtual-scrolling.d.ts +82 -101
  360. package/dist/visual-testing.d.ts +10 -9
  361. package/dist/vue-template.d.ts +0 -23
  362. package/dist/web-components/css-scoping.d.ts +11 -21
  363. package/dist/web-components.d.ts +58 -81
  364. package/dist/x-element.d.ts +1 -0
  365. package/package.json +6 -6
  366. package/stx.d.ts +2 -2
  367. package/dist/app-service-worker.d.ts +0 -165
  368. package/dist/chunk-49gwmcrn.js +0 -2
  369. package/dist/chunk-6va5pe2m.js +0 -2
  370. package/dist/chunk-bm2q1srp.js +0 -2
  371. package/dist/signals-context-runtime.d.ts +0 -2
  372. package/dist/signals-drawer-runtime.d.ts +0 -2
  373. package/dist/signals-host-runtime.d.ts +0 -9
  374. package/dist/signals-loop-conditional-runtime.d.ts +0 -2
  375. package/dist/signals-manifest-hydration-runtime.d.ts +0 -2
  376. package/dist/signals-notify-runtime.d.ts +0 -2
  377. package/dist/signals-optimistic-runtime.d.ts +0 -2
  378. package/dist/signals-overlay-runtime.d.ts +0 -2
  379. package/dist/signals-scope-disposal-runtime.d.ts +0 -2
  380. package/dist/signals-spa-load-control-runtime.d.ts +0 -2
  381. package/dist/signals-storage-runtime.d.ts +0 -2
@@ -1,2 +1,2 @@
1
1
  /** Reactive if/else-if/else chain binding for the generated client runtime. */
2
- export declare const SIGNALS_IF_CHAIN_RUNTIME = " // Reactive if/else-if/else chain. A single effect drives mutual exclusion:\n // on each run it picks the first branch whose condition is truthy (the\n // trailing x-else always matches), inserts that branch, and removes\n // whichever branch was previously shown. One effect for the whole chain\n // means branches can't transiently both render or both vanish in a tick,\n // and a single source signal isn't subscribed N times. See #1734.\n function bindIfChain(chain, passedScope = componentScope) {\n var head = chain[0].el;\n if (head.__stx_if_bound) { console.log('[stx] bindIfChain SKIPPED (head already bound):', head.tagName, chain.map(function(c) { return c.attr; }).join(',')); return; }\n console.log('[stx] bindIfChain entry:', head.tagName, 'branches:', chain.map(function(c) { return c.attr; }).join(','));\n\n var parent = head.parentNode;\n if (!parent) { console.warn('[STX] bindIfChain: head element has no parent, skipping'); return; }\n\n var capturedComponentScope = { ...passedScope };\n\n // Detach every branch up-front, leaving a positional placeholder comment\n // so reinsertion preserves source order. Mark each as a chain member so\n // the parent's snapshot child-iteration skips the detached (non-active)\n // branches instead of bringing their content to life. The active branch\n // is re-inserted below and IS connected, so it processes normally.\n chain.forEach(function(b) {\n preserveConditionalComponentScopes(b.el, capturedComponentScope);\n b.el.__stx_if_bound = true;\n b.el.__stx_chain_member = true;\n b.el.__stx_chain_active = false;\n b.el.__stx_if_visible = state(false);\n b.capturedElementScope = findElementScope(b.el);\n b.placeholder = stxHost.anchor('stx-if-chain');\n stxHost.insert(parent, b.placeholder, b.el);\n b.el.removeAttribute(b.attr);\n // A <template> branch (the wrapper convertSignalDirectivesToAttributes\n // emits for a multi-child / text branch) is INERT \u2014 inserting the element\n // renders nothing, its content lives in a document fragment. Clone that\n // content ONCE into a stable node set we toggle in and out, exactly as\n // bindIf/bindFor already do for template elements. An element branch is\n // its own single node. Without this, a multi-element @else / @else-if\n // branch rendered blank the moment the markup was well-formed enough to\n // survive as a real <template> (the #1784 markup fix). See #1784.\n b.isTemplate = b.el.tagName === 'TEMPLATE';\n // A template branch renders CLONES, re-cloned on every show, and marks\n // where they end -- the same contract the single-template :if got in\n // #1955. Its content was cloned once here and that one node set was\n // toggled in and out, which broke two ways as soon as the branch held a\n // structural directive: a :for inside it replaces its own source element\n // with a placeholder comment and renders rows as SIBLINGS, so hiding\n // removed neither (the rows were never in this list, and the source node\n // it did hold was already detached, so the parentNode guard skipped it)\n // and both branches stayed on screen at once. Re-showing then re-inserted\n // that source element, painting the literal text of its interpolations.\n // An element branch still owns exactly the node it was bound to: whatever\n // a directive inside it renders is inside that element.\n // Snapshot the content BEFORE anything processes it, and clone each show\n // from the snapshot rather than from the live template. A nested :for\n // does not leave content pristine -- processing moves its row source out\n // and the attributes it consumed (x-model, :id) do not come back -- so a\n // second clone taken from the element would arrive already stripped, with\n // no binding and no way to acquire one.\n b.pristine = b.isTemplate ? stxHost.clone(b.el.content) : null;\n b.nodes = b.isTemplate ? [] : [b.el];\n b.endMarker = null;\n stxHost.remove(b.el);\n b.childrenProcessed = false;\n });\n\n // Per-branch evaluator. Evaluated inside the chain effect via with()\n // (like evalLazy) so ONLY the signals the expression actually references\n // register as dependencies \u2014 not every signal in scope. The old form\n // (new Function(...Object.keys(scope)) called with ...Object.values of\n // the unwrap proxy) read every scope value through the proxy to build the\n // positional args, subscribing the effect to ALL scope signals, so it\n // re-ran on every unrelated mutation (#1738). with() only triggers the\n // proxy's get-trap for identifiers the expression names.\n //\n // Two passes, same as bindIf (#1733): proxy pass first (so bare-ref\n // comparisons like count === 0 read the signal as a value), raw-scope\n // retry second (so call-syntax like count() === 0 works \u2014 the proxy\n // would have unwrapped count to a value, making count() throw).\n function evalBranch(b) {\n var expression = b.expr;\n if (/^__[A-Z_]+__$/.test(expression.trim())) return expression;\n var scope = { ...globalHelpers, ...capturedComponentScope, ...(b.capturedElementScope || {}) };\n try {\n var unwrapScope = createExpressionAutoUnwrapProxy(scope, expression);\n // Compiled over the names the expression mentions (see __stxCompileScoped).\n var fn = __stxCompileScoped(unwrapScope, [], 'return ' + expression + '');\n return fn(...__stxArgs(fn, unwrapScope));\n }\ncatch (e1) {\n try {\n var fn2 = __stxCompileScoped(scope, [], 'return ' + expression + '');\n return fn2(...__stxArgs(fn2, scope));\n }\ncatch (e2) {\n if (!(e2 instanceof ReferenceError) && !(e2 instanceof TypeError)) console.warn('[STX] Expression error:', expression, e2);\n return '';\n }\n }\n }\n\n var currentIdx = -1;\n\n effect(function() {\n // Evaluate EVERY branch's condition each run (not for-break) so the\n // reactive tracker registers dependencies on exactly the signals the\n // branch expressions reference \u2014 and on ALL of them, so a transition\n // from a later branch back to an earlier one still re-fires. Then pick\n // the first truthy branch (terminal x-else always matches).\n //\n // Pre-fix (#1738) this used a for-break picker, which only subscribed\n // to signals up to the first truthy branch; to stay correct it then\n // eagerly read EVERY signal in scope \u2014 a sledgehammer that re-ran this\n // effect on every unrelated signal mutation in the scope (50+ no-op\n // runs per page load on real apps). Evaluating all branches subscribes\n // narrowly to just the branch signals instead.\n var pickedIdx = -1;\n for (var i = 0; i < chain.length; i++) {\n var b = chain[i];\n var matched = b.terminal ? true : !!evalBranch(b);\n if (matched && pickedIdx === -1) pickedIdx = i;\n }\n\n console.log('[stx] bindIfChain pick:', pickedIdx, 'of', chain.length, '(', pickedIdx >= 0 ? chain[pickedIdx].attr : 'none', ') prev:', currentIdx);\n if (__stxDevtoolsTracking) {\n var __ifScope = null;\n try { __ifScope = stxHost.scopeOf(head); } catch (e) { __ifScope = null; }\n __stxDevtoolsRecordIf({\n scopeId: __ifScope ? __ifScope.getAttribute('data-stx-scope') : null,\n branches: chain.map(function(c) { return c.attr; }),\n picked: pickedIdx,\n pickedAttr: pickedIdx >= 0 ? chain[pickedIdx].attr : null,\n prev: currentIdx\n });\n }\n if (pickedIdx === currentIdx) return;\n\n // Remove the previously-shown branch. Do NOT disposeSubtreeScopes here:\n // a chain branch is a TOGGLE (re-shown when its condition matches again),\n // not a permanent unmount, and a nested data-stx-scope inside it can't be\n // recreated once deleted from window.stx._scopes (its setup IIFE ran\n // once at page load). Deleting it broke re-show of nested scoped\n // components under reactive conditionals (#1737). Permanent disposal is\n // still handled by bindFor (item removal) and cleanupContainer (SPA nav).\n if (currentIdx !== -1) {\n var gone = chain[currentIdx];\n gone.el.__stx_chain_active = false;\n gone.el.__stx_if_visible.set(false);\n // Unmount what the branch held, as a single :if does, before any of\n // it leaves the page.\n var leavingNodes = gone.nodes.filter(function (n) { return n.parentNode; });\n if (gone.isTemplate && gone.endMarker && gone.endMarker.parentNode) {\n leavingNodes = [];\n for (var walk = gone.placeholder.nextSibling; walk && walk !== gone.endMarker; walk = walk.nextSibling) leavingNodes.push(walk);\n }\n suspendSubtreeScopes(leavingNodes);\n\n if (gone.isTemplate) {\n // Everything this branch rendered goes, not just the clones it owns:\n // a nested :for or :if renders siblings of its own that no clone list\n // contains. The marker bounds the range, so a sibling that belongs to\n // a later branch or to ordinary markup is never touched.\n if (gone.endMarker && gone.endMarker.parentNode) {\n var doomed = gone.placeholder.nextSibling;\n while (doomed && doomed !== gone.endMarker) {\n var nextDoomed = doomed.nextSibling;\n disposeSubtreeEffects(doomed);\n stxHost.remove(doomed);\n doomed = nextDoomed;\n }\n stxHost.remove(gone.endMarker);\n gone.endMarker = null;\n }\n gone.nodes.forEach(function (n) {\n if (!n.parentNode) return;\n disposeSubtreeEffects(n);\n stxHost.remove(n);\n });\n // The next show clones afresh and processes again, so these effects\n // are finished with; leaving them bound only accumulates work (#1954).\n if (typeof gone.el.__stx_chain_disposers === 'function') {\n try { gone.el.__stx_chain_disposers(); }\ncatch (e) { /* a disposer of its own is not this branch's problem */ }\n gone.el.__stx_chain_disposers = null;\n }\n gone.nodes = [];\n gone.childrenProcessed = false;\n }\n else {\n gone.nodes.forEach(function (n) {\n if (!n.parentNode) return;\n // Detached nodes are out of reach of a DOM walk, so a row removed\n // while this branch is hidden could not dispose the effects it was\n // processed with (#1954). Same registry the single-element :if uses.\n var parentEl = n.parentNode;\n if (!parentEl.__stx_detached_if) parentEl.__stx_detached_if = new Set();\n parentEl.__stx_detached_if.add(n);\n stxHost.remove(n);\n });\n }\n }\n\n // Insert + process the newly-picked branch.\n if (pickedIdx !== -1) {\n var pick = chain[pickedIdx];\n pick.el.__stx_chain_active = true;\n // Insert this branch's node(s) before the placeholder's next sibling.\n // The anchor is captured once so the nodes stack in source order.\n var anchor = pick.placeholder.nextSibling;\n var pickHost = pick.placeholder.parentNode;\n if (pick.isTemplate && pick.nodes.length === 0)\n pick.nodes = Array.prototype.slice.call(stxHost.clone(pick.pristine).childNodes);\n pick.nodes.forEach(function (n) {\n if (pickHost.__stx_detached_if) pickHost.__stx_detached_if.delete(n);\n stxHost.insert(pickHost, n, anchor);\n });\n pick.el.__stx_if_visible.set(true);\n // Bound AFTER the clones, so hiding can remove whatever a structural\n // directive inside the branch renders as their sibling.\n if (pick.isTemplate) {\n if (!pick.endMarker) pick.endMarker = stxHost.anchor('stx-if-chain-end');\n stxHost.insert(pickHost, pick.endMarker, anchor);\n }\n pick.el.__stx_shown_at = performance.now();\n // An element branch shown before keeps its bindings and its scopes;\n // the components in it mount again (a template branch is cloned afresh\n // and mounts through hydrateComponentScopes below).\n if (pick.childrenProcessed) {\n var shownNodes = pick.nodes;\n queueMicrotask(function () {\n if (pick.el.__stx_chain_active) peek(function () { resumeSubtreeScopes(shownNodes); });\n });\n }\n if (!pick.childrenProcessed) {\n pick.childrenProcessed = true;\n // Hydrate before the outer scope walk can see the inserted branch.\n // Chromium executes scripts cloned from template.content as soon as\n // they are connected, so deferring this pass allowed the global walk\n // to process projected slot expressions without the loop caller\n // scope. peek() keeps this synchronous pass from subscribing child\n // reads to the current chain effect.\n // Tracked on the branch element: this runs inside the chain effect,\n // where no tracker is active, so without a handle the effects of a\n // branch picked after render survive their row's removal (#1954).\n pick.el.__stx_chain_disposers = trackEffects(function () {\n peek(function () {\n var childScope = { ...globalHelpers, ...capturedComponentScope, ...(pick.capturedElementScope || {}) };\n // Components compiled inside any branch of an if/else-if/else\n // chain carry scoped setup scripts with them. Branch nodes are\n // detached before those scripts can execute, so simply\n // re-inserting the selected branch leaves component props,\n // events, directives, and projected slot expressions inert.\n // Hydrate those scopes before the normal subtree walk, matching\n // the single-template :if and :for insertion paths.\n var previouslyTrackedNodes = new Set();\n pick.nodes.forEach(function (n) {\n if (n && n.__stx_disposers) previouslyTrackedNodes.add(n);\n });\n hydrateComponentScopes(pick.nodes, childScope);\n pick.nodes.forEach(function (n) {\n if (n.nodeType !== 1) return; // whitespace/text between template children\n // A scoped component receives its disposer in the outer scope\n // walk immediately after processElement returns from binding\n // this conditional. That first pass intentionally stops at\n // :if, so a disposer does not mean its children were hydrated.\n if (previouslyTrackedNodes.has(n) || !n.__stx_disposers)\n processElement(n, childScope);\n n.removeAttribute('x-cloak');\n n.querySelectorAll('[x-cloak]').forEach(function (c) { c.removeAttribute('x-cloak'); });\n });\n resumeDetachedBranches();\n });\n });\n }\n }\n\n currentIdx = pickedIdx;\n });\n }\n\n // Shown branches whose deferred bind found them off the page: an enclosing\n // :if, bound later in the same pass, hid them between the queue and the run.\n // Their own condition has not changed, so their effect never runs again to\n // retry; each resumes here when an enclosing branch puts it back.";
2
+ export declare const SIGNALS_IF_CHAIN_RUNTIME: string;
@@ -1,2 +1,2 @@
1
1
  /** Single-branch conditional binding for the generated client runtime. */
2
- export declare const SIGNALS_IF_RUNTIME = " const detachedBranches = new Set();\n function resumeDetachedBranches() {\n if (!detachedBranches.size) return;\n Array.from(detachedBranches).forEach(function(resume) {\n if (!resume.el.isConnected) return;\n detachedBranches.delete(resume);\n resume();\n });\n }\n\n function bindIf(el, passedScope = componentScope, attrName = '@if') {\n // Guard: prevent double-binding on the same element\n if (el.__stx_if_bound) { console.log('[stx] bindIf SKIPPED (already bound):', el.getAttribute(attrName) || '(attr removed)', 'on', el.tagName); return; }\n el.__stx_if_bound = true;\n\n const expr = el.getAttribute(attrName);\n let parent = el.parentNode;\n\n // Guard: if element has no parent, it's detached - skip processing\n if (!parent) {\n console.warn('[STX] bindIf: element has no parent, skipping');\n return;\n }\n\n const placeholder = stxHost.anchor('stx-if');\n // Marks where this branch's rendered content ENDS (stacksjs/stx#1955).\n // Hiding used to remove only the cloned nodes, but a structural directive\n // directly inside the template renders its own output as siblings that are\n // not among those clones -- a <template :for> at the top level of a\n // <template :if> left every row on screen after the branch went false.\n // Only the template branch needs it; the single-element branch owns exactly\n // the node it was bound to.\n let endMarker = null;\n let isInserted = true;\n\n // Handle <template> elements specially - clone their content\n const isTemplate = el.tagName === 'TEMPLATE';\n if (!isTemplate) el.__stx_if_visible = state(true);\n const componentSetupSiblings = isTemplate ? [] : findConditionalComponentSetupSiblings(el);\n let currentNodes = isTemplate ? [] : [el, ...componentSetupSiblings];\n\n // Capture BOTH element scope AND passedScope NOW before anything changes\n // passedScope may contain @for iteration variables or parent component signals\n const capturedElementScope = findElementScope(el);\n const capturedComponentScope = { ...passedScope };\n\n preserveConditionalComponentScopes(el, capturedComponentScope);\n stxHost.insert(parent, placeholder, el);\n el.removeAttribute(attrName);\n\n if (isTemplate) {\n // Nothing is cloned until the condition holds: the effect below clones\n // template.content on the first true and binds it then. Every branch\n // used to be cloned and inserted up front and the false ones removed, so\n // a false branch still built its elements - in WebKit a <video> or\n // <audio> sets up a media player as it is created.\n isInserted = false;\n stxHost.remove(el); // Remove the template element itself\n }\n\n // Helper to evaluate with captured scope (auto-unwraps signals).\n // A with-scope resolves only identifiers the expression actually references,\n // so the conditional subscribes narrowly instead of reading every signal\n // in a component scope. That broad subscription made an unrelated ref\n // update re-enter structural removal while the real condition was already\n // removing the same subtree. First try the auto-unwrap proxy (so a bare\n // comparison like count > 5 reads the signal value), then retry with the\n // raw scope so call syntax like count() === 0 still works (#1733).\n const evalExpr = (expression) => {\n // Skip placeholder expressions like __TITLE__ (build-time placeholders)\n if (/^__[A-Z_]+__$/.test(expression.trim())) {\n return expression;\n }\n try {\n const scope = { ...globalHelpers, ...capturedComponentScope, ...(capturedElementScope || {}) };\n const unwrapScope = createExpressionAutoUnwrapProxy(scope, expression);\n const fn = __stxCompileScoped(unwrapScope, [], 'return ' + expression + '');\n return fn(...__stxArgs(fn, unwrapScope));\n }\ncatch (e1) {\n try {\n // Retry without the unwrap proxy so call-syntax (signal()) works.\n const scope2 = { ...globalHelpers, ...capturedComponentScope, ...(capturedElementScope || {}) };\n const fn2 = __stxCompileScoped(scope2, [], 'return ' + expression + '');\n return fn2(...__stxArgs(fn2, scope2));\n }\ncatch (e2) {\n if (!(e2 instanceof ReferenceError) && !(e2 instanceof TypeError)) console.warn('[STX] Expression error:', expression, e2);\n return '';\n }\n }\n };\n\n // Track if children have been processed\n let childrenProcessed = false;\n\n // Helper to process children with captured scope\n const processChildrenWithScope = () => {\n // Build the combined scope for children - no need to modify global componentScope\n // Just pass the scope explicitly to processElement\n const childScope = { ...globalHelpers, ...capturedComponentScope, ...(capturedElementScope || {}) };\n\n\n Array.from(el.childNodes).forEach(child => processElement(child, childScope));\n\n childrenProcessed = true;\n };\n\n // A <template :if> inserts clones of template.content rather than the\n // template element itself. Those clones still need the normal directive\n // and interpolation pass. Previously the initially-visible branch was\n // inserted and left inert, so bindings such as :text and {{ expression }}\n // leaked into the rendered UI until the condition toggled.\n const processTemplateNodes = (nodes) => {\n const childScope = { ...globalHelpers, ...capturedComponentScope, ...(capturedElementScope || {}) };\n // Components compiled inside a <template :if> carry setup scripts in the\n // template content. Browser-cloned scripts are inert, so register their\n // scopes and forwarded props before walking the inserted branch. This is\n // the same component hydration path used by <template :for>.\n hydrateComponentScopes(nodes, childScope);\n nodes.forEach(node => {\n if (!node.__stx_disposers && node.tagName !== 'SCRIPT')\n node.__stx_effect_disposers = trackEffects(function() { processElement(node, childScope); });\n if (node.nodeType === 1) {\n node.removeAttribute('x-cloak');\n node.querySelectorAll('[x-cloak]').forEach(c => c.removeAttribute('x-cloak'));\n }\n });\n resumeDetachedBranches();\n };\n\n // Evaluate the :if expression \u2014 use direct signal read for simple refs,\n // falling back to evalExpr for complex expressions\n const fullScope = { ...globalHelpers, ...capturedComponentScope, ...(capturedElementScope || {}) };\n const directSignal = fullScope[expr];\n\n effect(() => {\n parent = followPlaceholder(placeholder, parent, currentNodes);\n var value;\n if (directSignal && (directSignal._isSignal || directSignal._isDerived)) {\n value = directSignal();\n console.log('[stx] bindIf effect (direct):', expr, '\u2192', value, 'isInserted:', isInserted);\n } else {\n value = evalExpr(expr);\n }\n\n if (isTemplate) {\n if (value && !isInserted) {\n // Re-insert cloned content\n currentNodes = Array.from(el.content.childNodes).map(n => stxHost.clone(n));\n const insertionAnchor = placeholder.nextSibling;\n currentNodes.forEach(node => stxHost.insert(parent, node, insertionAnchor));\n // Bound AFTER the clones, so hiding can remove whatever a nested\n // structural directive rendered as their sibling (#1955).\n if (!endMarker) endMarker = stxHost.anchor('stx-if-end');\n stxHost.insert(parent, endMarker, insertionAnchor);\n processTemplateNodes(currentNodes);\n childrenProcessed = true;\n // Stamp insertion time for click propagation guard\n currentNodes.forEach(function(n) { if (n.nodeType === 1) n.__stx_shown_at = performance.now(); });\n isInserted = true;\n }\nelse if (!value && isInserted) {\n // Remove all current nodes. Do NOT disposeSubtreeScopes \u2014 :if is a\n // toggle, not a permanent unmount; see the single-element branch\n // below and #1737. Effects are disposed, though: these clones are never\n // reused, and a re-show clones afresh, so leaving them bound only\n // accumulates work (#1954).\n //\n // Everything between the placeholder and the end marker goes, not\n // just the clones: a nested :for or :if renders siblings of its own\n // that no clone list contains (#1955).\n // Only walk the range when THIS binding inserted the content and\n // left its marker. Without that guard the walk ran to the end of the\n // parent and took a sibling <template :if> with it -- the initial\n // server-rendered state has no marker to stop at.\n if (endMarker && endMarker.parentNode === parent) {\n var leaving = [];\n for (var cursor = placeholder.nextSibling; cursor && cursor !== endMarker; cursor = cursor.nextSibling) leaving.push(cursor);\n suspendSubtreeScopes(leaving);\n var doomed = placeholder.nextSibling;\n while (doomed && doomed !== endMarker) {\n var nextDoomed = doomed.nextSibling;\n disposeSubtreeEffects(doomed);\n stxHost.remove(doomed);\n doomed = nextDoomed;\n }\n stxHost.remove(endMarker);\n }\n suspendSubtreeScopes(currentNodes.filter(node => node.parentNode));\n currentNodes.forEach(node => { disposeSubtreeEffects(node); stxHost.remove(node); });\n currentNodes = [];\n isInserted = false;\n childrenProcessed = false;\n }\n else if (value && isInserted && !childrenProcessed) {\n // Initial template content is cloned before the effect runs. Process\n // it after the condition is confirmed so hidden branches stay inert.\n // Keep hydration synchronous so the outer scope walk cannot bind\n // caller-owned slot expressions first, while peek() prevents child\n // reads from subscribing to this conditional effect.\n childrenProcessed = true;\n peek(function() {\n if (isInserted) processTemplateNodes(currentNodes);\n });\n }\n }\nelse {\n // Native hosts keep a view hierarchy rather than a DOM subtree. Route\n // the conditional through the same visibility contract as :show so a\n // false branch is hidden in the first render and in every loop row;\n // the structural remove/insert below still preserves browser and\n // native lifecycle behaviour when the branch changes.\n if (stxHost.isNative) stxHost.setVisible(el, !!value);\n if (value && !isInserted) {\n console.log('[stx] bindIf INSERTING element for :if=' + expr);\n const insertionAnchor = placeholder.nextSibling;\n currentNodes.forEach(node => stxHost.insert(parent, node, insertionAnchor));\n if (parent && parent.__stx_detached_if) currentNodes.forEach(node => parent.__stx_detached_if.delete(node));\n el.__stx_if_visible.set(true);\n el.__stx_shown_at = performance.now();\n isInserted = true;\n // A previously hydrated parent skips hydrateShownBranch on re-show.\n // Its children may have become visible while it was detached, so\n // resume their pending bindings now that the subtree is connected.\n peek(resumeDetachedBranches);\n // Shown before, so the components in it mounted and were suspended\n // when it hid. They mount again now -- in a microtask, the same\n // moment their first mount ran, and only if still shown by then.\n if (childrenProcessed) {\n queueMicrotask(function() {\n if (isInserted) peek(function() { resumeSubtreeScopes(currentNodes); });\n });\n }\n }\nelse if (!value && isInserted) {\n console.log('[stx] bindIf REMOVING element for :if=' + expr, 'el.isConnected:', el.isConnected, 'parent:', parent.tagName);\n el.__stx_if_visible.set(false);\n // Unmounted, not disposed: the components in it release what they\n // hold while their markup is still on the page, and keep their scopes.\n suspendSubtreeScopes(currentNodes);\n // Do NOT disposeSubtreeScopes here. :if is a TOGGLE \u2014 the element is\n // re-shown when the condition flips back \u2014 not a permanent unmount.\n // A nested data-stx-scope inside this subtree is created once by its\n // setup IIFE at page load and stored in window.stx._scopes; deleting\n // it on hide left re-show unable to recreate it, so nested scoped\n // components under reactive conditionals rendered all branches at\n // once (#1737). Permanent disposal stays in bindFor (item removal)\n // and cleanupContainer (SPA navigation). The double-bind guards make\n // re-show idempotent, so toggling doesn't leak.\n currentNodes.forEach(node => stxHost.remove(node));\n // Detached nodes are out of reach of a DOM walk, so an ancestor row or\n // branch removed while this is hidden could not dispose their effects\n // (#1954). Record them on the parent that keeps the placeholder.\n if (parent) {\n if (!parent.__stx_detached_if) parent.__stx_detached_if = new Set();\n currentNodes.forEach(node => parent.__stx_detached_if.add(node));\n }\n isInserted = false;\n console.log('[stx] bindIf REMOVED, el.isConnected:', el.isConnected);\n }\n // Process the entire subtree when element is visible and not yet processed.\n // peek() keeps child effects from subscribing to this bindIf's tracked\n // signals. Use capturedComponentScope (not global componentScope) so\n // iteration variables from an enclosing for-loop remain in scope.\n // Process the element itself, not just children, so sibling directives\n // on the same element (e.g. text binding alongside if) fire too. The if\n // attribute was already removed, so no recursion.\n //\n // Synchronously when the branch is on the page, as the template and\n // if/else-chain branches already are. This pass used to wait for a\n // timer, so every :if (and each :for inside one) filled in a frame\n // after the rest of the page was bound: a screen opened from a tab bar\n // showed its sections arriving one after another.\n if (value && isInserted && !childrenProcessed) {\n childrenProcessed = true;\n // Until this pass runs, the shown subtree still holds literal {{ }}.\n // Flag it so the hydration audit doesn't report those as a binding\n // miss when the pass is deferred (#1773).\n el.__stx_if_pending = true;\n var hydrateShownBranch = function() {\n // Removed with its row, or hidden again, before this ran. Hydrating\n // a detached element now creates effects nothing will dispose\n // (#1954). Leave it unprocessed so the next show schedules the pass.\n if (!el.isConnected) {\n childrenProcessed = false;\n el.__stx_if_pending = false;\n // Hidden by an ancestor rather than by this condition (a page :if\n // around a component whose own :if queued this pass), the branch\n // comes back without this effect running, and a component shown\n // again kept its :for rows as raw markup.\n var resume = function() {\n if (!isInserted || childrenProcessed) return;\n childrenProcessed = true;\n el.__stx_if_pending = true;\n peek(hydrateShownBranch);\n };\n resume.el = el;\n detachedBranches.add(resume);\n return;\n }\n var childScope = { ...globalHelpers, ...capturedComponentScope, ...(capturedElementScope || {}) };\n // A false single-element conditional is detached before the\n // DOMContentLoaded component-scope pass. When it becomes visible,\n // hydrate any component roots in the restored subtree first so\n // projected slot bindings and component-local directives receive\n // the same lifecycle as components inserted by template :if.\n var wasTrackedBeforeConditionalHydration = !!el.__stx_disposers;\n hydrateComponentScopes(currentNodes, childScope);\n // Tracked on its own property so an ancestor row or branch removal\n // reaches these effects too (#1954). This runs after the enclosing\n // tracker has closed, so nothing else would collect them.\n if (wasTrackedBeforeConditionalHydration || !el.__stx_disposers)\n el.__stx_if_disposers = trackEffects(function() { processElement(el, childScope); });\n // Remove x-cloak from the inserted subtree \u2014 the initial\n // cloak removal (after processElement on the root) already\n // ran before this deferred processing, so newly-inserted\n // :if children still have x-cloak and stay hidden.\n el.removeAttribute('x-cloak');\n el.querySelectorAll('[x-cloak]').forEach(function(c) { c.removeAttribute('x-cloak'); });\n // Deferred bind complete \u2014 the audit may inspect this subtree now.\n el.__stx_if_pending = false;\n // Branches inside this one that were hidden with it can bind now.\n resumeDetachedBranches();\n };\n // In a microtask, not inside this effect's own run: child effects\n // created while it is running saw the data mid-change (a screen\n // swapping workouts) and recorded expressions that had never\n // evaluated. A microtask still runs before the browser paints, so\n // the branch is bound in the first frame all the same. A branch\n // shown while detached (inside content not on the page yet) waits a\n // macrotask, when it has been placed.\n if (el.isConnected) {\n // A native host sends the insertion as soon as its current\n // mutation turn ends. Hydrating in a later microtask would put the\n // handler registration in a second batch, leaving a same-turn tap\n // with the source expression instead of a native handler id.\n if (stxHost.isNative) peek(hydrateShownBranch);\n else queueMicrotask(function() { peek(hydrateShownBranch); });\n }\n else setTimeout(hydrateShownBranch, 0);\n }\n }\n });\n }\n";
2
+ export declare const SIGNALS_IF_RUNTIME: string;
@@ -1,2 +1,2 @@
1
1
  /** Deferred island hydration scheduling for the generated client runtime. */
2
- export declare const SIGNALS_LAZY_HYDRATION_RUNTIME = " // Lazy hydration: defer processElement for subtrees marked with stx-hydrate.\n // Triggers: \"visible\" (IntersectionObserver), \"idle\" (requestIdleCallback),\n // \"interaction\" (mouseenter/click/focus), \"media:<query>\" (matchMedia).\n function deferHydration(el, trigger, scope) {\n if (el.__stx_hydration_scheduled) return;\n el.__stx_hydration_scheduled = true;\n\n var run = function() {\n if (el.__stx_hydrated) return;\n el.__stx_hydrated = true;\n el.__stx_hydration_cancel = null; // trigger consumed \u2014 nothing left to cancel\n el.removeAttribute('stx-hydrate');\n var sid = el.getAttribute && el.getAttribute('data-stx-scope');\n\n // Everything downstream of the island setup running: merge the now-\n // registered scope, bind the subtree, flush onMount, announce hydration.\n // Factored out so the async chunked path can run it from a <script> load\n // event while the inline path runs it synchronously (#1746).\n var finishHydrate = function() {\n var effectiveScope = scope;\n if (sid) {\n var reg = window.stx._scopes ? window.stx._scopes[sid] : null;\n if (reg) effectiveScope = Object.assign({}, scope || {}, reg);\n }\n // Walk children and process them with the (now scope-merged) context\n Array.from(el.children).forEach(function(child) { processElement(child, effectiveScope); });\n // Also process the element itself (attributes/bindings on the host)\n processAttributesOnly(el, effectiveScope);\n // Fire this scope's onMount now that it has actually hydrated \u2014 the\n // initial mount pass deferred it for stx-hydrate scopes so onMount lands\n // on hydration, not at page load (#1746). Guarded by __mounted so it\n // never double-fires with the eager path.\n var sv = sid && window.stx._scopes ? window.stx._scopes[sid] : null;\n if (sv && sv.__mountCallbacks && !sv.__mounted) {\n sv.__mounted = true;\n runMountCallbacks(sv.__mountCallbacks, scopeDestroySink(sv));\n }\n window.dispatchEvent(new CustomEvent('stx:hydrated', { detail: { el: el, trigger: trigger } }));\n };\n\n // Island (#1746): the component's setup script was emitted inert\n // (type=\"stx/island\") so the browser skipped it at parse. Run it now \u2014 it\n // registers the scope (signals + methods) AND runs any side-effectful\n // setup (e.g. a fetch in the <script client> body) at hydration time.\n var islandScript = sid ? document.querySelector('script[data-stx-island=\"' + sid + '\"]') : null;\n if (islandScript && !islandScript.__stx_ran) {\n islandScript.__stx_ran = true;\n var chunkSrc = islandScript.getAttribute && islandScript.getAttribute('data-stx-src');\n if (chunkSrc) {\n // Chunked island (production build): the IIFE lives in a separate\n // file fetched only now. Load it via a real <script src> (CSP-clean \u2014\n // no eval/new Function) and defer ALL downstream work to its load\n // event, since the scope isn't registered until the chunk executes.\n var s = document.createElement('script');\n s.src = chunkSrc;\n // Subresource Integrity (opt-in at build): pin the chunk's bytes.\n var integ = islandScript.getAttribute('data-stx-integrity');\n if (integ) s.integrity = integ;\n s.onload = finishHydrate;\n s.onerror = function() {\n // Network error / 404: the island can't become interactive. Log,\n // emit an observable event (analytics/monitoring can react), then\n // best-effort finish. The server-rendered HTML stays visible\n // (x-cloak was already removed on arming) \u2014 it just won't wire up.\n console.error('[stx] island chunk load failed:', sid, chunkSrc);\n window.dispatchEvent(new CustomEvent('stx:island-error', { detail: { el: el, scopeId: sid, src: chunkSrc } }));\n finishHydrate();\n };\n document.head.appendChild(s);\n return; // finishHydrate runs from the chunk's load event\n }\n // Inline island (dev / SSR / chunking off): execute synchronously.\n // eslint-disable-next-line no-new-func\n try { (new Function(islandScript.textContent))(); }\n catch (e) { console.error('[stx] island setup error:', sid, e); }\n }\n finishHydrate();\n };\n\n // Record how to cancel a still-pending trigger so SPA navigation can tear it\n // down \u2014 otherwise an unhydrated island's observer/timer/listener leaks and\n // may fire run() on a detached element after the page swapped (#1746).\n // Cleared once run() fires (it guards on __stx_hydrated anyway).\n if (trigger === 'idle') {\n if (typeof requestIdleCallback === 'function') {\n var idleId = requestIdleCallback(run, { timeout: 2000 });\n el.__stx_hydration_cancel = function() { if (typeof cancelIdleCallback === 'function') cancelIdleCallback(idleId); };\n }\n else {\n var idleTimer = setTimeout(run, 200);\n el.__stx_hydration_cancel = function() { clearTimeout(idleTimer); };\n }\n }\n else if (trigger === 'visible') {\n if (typeof IntersectionObserver === 'function') {\n var io = new IntersectionObserver(function(entries) {\n entries.forEach(function(e) {\n if (e.isIntersecting) { io.disconnect(); run(); }\n });\n }, { rootMargin: '50px' });\n io.observe(el);\n el.__stx_hydration_cancel = function() { io.disconnect(); };\n } else {\n run(); // fallback: no IO support, hydrate immediately\n }\n }\n else if (trigger === 'interaction') {\n var events = ['mouseenter', 'click', 'focusin', 'touchstart'];\n var handler = function() {\n events.forEach(function(ev) { el.removeEventListener(ev, handler); });\n run();\n };\n events.forEach(function(ev) { el.addEventListener(ev, handler, { once: true, passive: true }); });\n el.__stx_hydration_cancel = function() { events.forEach(function(ev) { el.removeEventListener(ev, handler); }); };\n }\n else if (trigger && trigger.indexOf('media:') === 0) {\n var query = trigger.slice(6);\n var mql = window.matchMedia(query);\n if (mql.matches) run();\n else {\n var mqHandler = function(e) {\n if (e.matches) { mql.removeEventListener('change', mqHandler); run(); }\n };\n mql.addEventListener('change', mqHandler);\n el.__stx_hydration_cancel = function() { mql.removeEventListener('change', mqHandler); };\n }\n }\n else {\n // Unknown trigger \u2014 hydrate immediately\n run();\n }\n }\n";
2
+ export declare const SIGNALS_LAZY_HYDRATION_RUNTIME: string;
@@ -1,2 +1,2 @@
1
1
  /** Lifecycle queues and scope-aware hook ownership for the client runtime. */
2
- export declare const SIGNALS_LIFECYCLE_RUNTIME = " // ==========================================================================\n // Lifecycle\n // ==========================================================================\n\n const mountCallbacks = [];\n const destroyCallbacks = [];\n\n function currentLifecycleScope() {\n var el = window.__STX_CURRENT_ELEMENT__;\n if (!el || !el.getAttribute || !window.stx || !window.stx._scopes) return null;\n var scopeId = el.getAttribute('data-stx-scope');\n return scopeId ? window.stx._scopes[scopeId] || null : null;\n }\n\n function onMount(fn) {\n var scope = currentLifecycleScope();\n if (scope) {\n scope.__mountCallbacks = scope.__mountCallbacks || [];\n scope.__mountCallbacks.push(fn);\n // Kept apart from the queue, which a flush drains: a component behind an\n // :if mounts again every time it is shown (see suspendSubtreeScopes).\n scope.__mountHooks = scope.__mountHooks || [];\n scope.__mountHooks.push(fn);\n return;\n }\n mountCallbacks.push(fn);\n }\n\n // Where an onDestroy called from inside a running mount callback belongs:\n // the queue runMountCallbacks is parking cleanups on, which is the mounting\n // component's own. Null outside a flush.\n //\n // Without it such a call, typically a composable like useEventListener\n // invoked in onMount, found no current element and went to the global\n // queue, and every stx:load drains that queue. A component that stays on\n // the page across navigations (one the layout renders) lost the listener at\n // the first navigation while its markup stayed bound (#1958).\n var activeDestroySink = null;\n\n function onDestroy(fn) {\n var scope = currentLifecycleScope();\n if (scope) {\n scope.__destroyCallbacks = scope.__destroyCallbacks || [];\n scope.__destroyCallbacks.push(fn);\n // Registered once, at setup, and owed at every unmount -- including each\n // time an :if hides the component (see suspendSubtreeScopes).\n scope.__destroyHooks = scope.__destroyHooks || [];\n scope.__destroyHooks.push(fn);\n return;\n }\n if (activeDestroySink) {\n activeDestroySink.push(fn);\n return;\n }\n destroyCallbacks.push(fn);\n }\n\n // Run mount callbacks and keep whatever teardown they hand back.\n //\n // A mount callback may return its own cleanup \u2014 the shape LifecycleCallback\n // has always declared, and the shape every peer framework uses. Only the two\n // component-factory paths honoured it; the other flush sites called fn() and\n // dropped the result on the floor, so the teardown never ran and nothing said\n // so. A listener or timer registered that way outlived its element and leaked\n // once per re-render (#1857).\n //\n // The sink argument is where a returned cleanup is parked: a scoped flush\n // passes that scope's __destroyCallbacks, a global flush passes the module\n // queue. (No backticks in this comment \u2014 it lives inside a template literal.)\n function runMountCallbacks(list, sink) {\n if (!list || !list.length) return;\n var target = sink || destroyCallbacks;\n // Drain before running. A mount callback fires once, and leaving the queue\n // in place made that untrue: the DOM-ready handler reaches this with the\n // same shared mountCallbacks array twice \u2014 once inside the per-root\n // hydration loop, then again for the global pass \u2014 and only emptied it\n // after the second call. So every onMount on a page with a data-stx root\n // ran twice, and a page with N roots ran them N+1 times. Every request the\n // hook made was duplicated with it.\n // Taking the batch out first also keeps a callback that registers another\n // onMount honest: the new one queues for the next flush instead of being\n // swallowed by the clear or replayed by the next caller.\n var batch = list.splice(0, list.length);\n // An onDestroy registered while the batch runs joins the same queue as a\n // returned cleanup. Saved and restored, so a mount that mounts something\n // else (stx.mount inside onMount) hands the outer sink back afterwards.\n var previousSink = activeDestroySink;\n activeDestroySink = target;\n try {\n for (var i = 0; i < batch.length; i++) {\n try {\n var cleanup = batch[i]();\n if (typeof cleanup === 'function') target.push(cleanup);\n }\n catch (e) { console.error('[stx] onMount error:', e); }\n }\n }\n finally {\n activeDestroySink = previousSink;\n }\n }\n\n // The scope's own teardown queue, created on demand so a scope that never\n // returns a cleanup does not carry an empty array around.\n function scopeDestroySink(scopeVars) {\n if (!scopeVars) return destroyCallbacks;\n scopeVars.__destroyCallbacks = scopeVars.__destroyCallbacks || [];\n return scopeVars.__destroyCallbacks;\n }\n\n // Drain any early mount/destroy calls captured by the pre-initialization shim\n if (window.__stx_early_mounts) { window.__stx_early_mounts.forEach(function(fn) { mountCallbacks.push(fn); }); window.__stx_early_mounts = null; }\n if (window.__stx_early_destroys) { window.__stx_early_destroys.forEach(function(fn) { destroyCallbacks.push(fn); }); window.__stx_early_destroys = null; }\n";
2
+ export declare const SIGNALS_LIFECYCLE_RUNTIME: string;
@@ -1,2 +1,2 @@
1
1
  /** Loop component scope remapping helpers for the generated client runtime. */
2
- export declare const SIGNALS_LOOP_COMPONENT_REMAP_RUNTIME = " var __forComponentScopeCounter = 0;\n var __forComponentSetupFactories = new Map();\n\n function forEachGroupElement(nodes, callback) {\n function visit(node, insideTemplateContent) {\n if (!node || node.nodeType !== Node.ELEMENT_NODE) return;\n callback(node, insideTemplateContent);\n\n // HTMLTemplateElement children live in template.content, outside the\n // element's ordinary descendant tree. Component roots and setup scripts\n // wrapped by caller-owned :if/:for directives must still be discoverable\n // for scope remapping before those templates are cloned.\n var entersTemplateContent = node.tagName === 'TEMPLATE' && node.content;\n var childRoot = entersTemplateContent\n ? node.content\n : node;\n Array.from(childRoot.childNodes || []).forEach(function(child) {\n visit(child, insideTemplateContent || entersTemplateContent);\n });\n }\n\n nodes.forEach(function(node) { visit(node, false); });\n }\n\n // A signal component expanded inside <template :for> carries a compiled\n // data-stx-scope id and setup script. cloneNode() used to duplicate that id\n // for every row, so all instances shared the first child's props and state.\n // Give each cloned component tree its own ids before insertion, and rewrite\n // the setup scripts that target those ids.\n function remapForComponentScopes(nodes) {\n var scopeMap = {};\n forEachGroupElement(nodes, function(node) {\n if (!node.hasAttribute || !node.hasAttribute('data-stx-scope')) return;\n var oldId = node.getAttribute('data-stx-scope');\n if (!oldId) return;\n if (!scopeMap[oldId])\n scopeMap[oldId] = oldId + '_for_' + (++__forComponentScopeCounter);\n // Keep the compiler's original id through any additional structural\n // clones. DOM cloneNode() preserves attributes but not expando fields.\n if (!node.hasAttribute('data-stx-template-scope'))\n node.setAttribute('data-stx-template-scope', oldId);\n node.setAttribute('data-stx-scope', scopeMap[oldId]);\n });\n\n var oldIds = Object.keys(scopeMap);\n if (!oldIds.length) return;\n\n forEachGroupElement(nodes, function(node) {\n if (node.attributes) {\n Array.from(node.attributes).forEach(function(rawAttribute) {\n var attribute = Array.isArray(rawAttribute)\n ? { name: rawAttribute[0], value: rawAttribute[1] }\n : rawAttribute;\n if (!attribute || attribute.name === 'data-stx-scope' || attribute.name === 'data-stx-template-scope') return;\n var value = attribute.value;\n if (typeof value !== 'string') return;\n oldIds.forEach(function(oldId) {\n if (value.indexOf(oldId) !== -1)\n value = value.split(oldId).join(scopeMap[oldId]);\n });\n if (value !== attribute.value) node.setAttribute(attribute.name, value);\n });\n }\n });\n }\n";
2
+ export declare const SIGNALS_LOOP_COMPONENT_REMAP_RUNTIME: string;
@@ -1,2 +1,2 @@
1
1
  /** Loop-row conditional deferral for the generated client runtime. */
2
- export declare const SIGNALS_LOOP_CONDITIONAL_RUNTIME = " // A :for row is a clone of its template, so a conditional element in the row\n // is built for every row whether or not its condition ever holds; :if then\n // parks the false ones. In WebKit a <video> or <audio> sets up a media player\n // as it is created: a message list with one media slot per attachment took\n // 1.8s to render instead of 18ms, and every row paid for elements it never\n // showed. Before any row is cloned, each eligible conditional element in the\n // row template is moved into a <template> carrying its condition. Template\n // content is inert, so a cloned row builds the element only when the\n // condition holds (bindIf clones template content on the first true).\n //\n // Left alone: an if/else chain (its branches must stay siblings), an element\n // that is also a loop, a component (its setup script is a sibling), and\n // anything holding a script.\n var IF_ATTRS = [':if', 'x-if', '@if'];\n var FOR_ATTRS = [':for', 'x-for', '@for'];\n function deferRowConditionals(root) {\n if (stxHost.isNative || !root || !root.querySelectorAll || typeof document === 'undefined' || !document.createElement) return;\n // Inert HTML template content is a DOM allocation optimisation. Native\n // hosts already clone recorded descriptors and bind conditions through\n // their host operations; their document facade has no template content.\n if (!document.createElement('template').content) return;\n // A walk, not a selector: escaping ':' and '@' in an attribute selector\n // through this generated source is easy to get wrong, and wrong throws.\n var candidates = Array.prototype.slice.call(root.querySelectorAll('*'));\n for (var i = 0; i < candidates.length; i++) {\n var el = candidates[i];\n if (el.tagName === 'TEMPLATE' || !el.parentNode) continue;\n var attr = null;\n for (var a = 0; a < IF_ATTRS.length; a++) {\n if (el.hasAttribute(IF_ATTRS[a])) { attr = IF_ATTRS[a]; break; }\n }\n if (!attr) continue;\n var skip = false;\n for (var f = 0; f < FOR_ATTRS.length; f++) {\n if (el.hasAttribute(FOR_ATTRS[f])) skip = true;\n }\n if (skip || getElseAttrInfo(el)) continue;\n var next = el.nextElementSibling;\n if (next && (getElseAttrInfo(next) || next.tagName === 'SCRIPT')) continue;\n if (el.hasAttribute('data-stx-scope') || el.hasAttribute('x-data') || el.querySelector('script')) continue;\n var holder = document.createElement('template');\n holder.setAttribute(attr, el.getAttribute(attr));\n el.removeAttribute(attr);\n el.parentNode.insertBefore(holder, el);\n holder.content.appendChild(el);\n }\n }\n";
2
+ export declare const SIGNALS_LOOP_CONDITIONAL_RUNTIME: string;
@@ -1,2 +1,2 @@
1
1
  /** Loop-row ownership and placeholder helpers for the generated client runtime. */
2
- export declare const SIGNALS_LOOP_ROW_RUNTIME = " // A loop row binds in its own iteration scope, and only its loop puts it\n // there. A walk from further out (an enclosing :if hydrating the branch it\n // shows) carries no item, so it used to bind whatever in the row was still\n // unbound -- a conditional's children, waiting for their own deferred pass\n // -- against a scope without the row: on a native screen every card's\n // compliance chip came out empty. Such a walk now leaves the row alone.\n function markLoopRow(row, itemName, itemSignal) {\n row.__stx_loop_row = { name: itemName, signal: itemSignal };\n }\n function isForeignToLoopRow(el, scope) {\n var row = el.__stx_loop_row;\n return !!row && (!scope || scope[row.name] !== row.signal);\n }\n\n // Where a structural directive's output goes is wherever its placeholder\n // is NOW, not the parent it was bound under. Something may move the\n // placeholder after binding: the router adopts the first page into a\n // retained screen (<div data-stx-screen>) by moving the container's\n // children, and an app may move a node itself. A :for or :if at the top\n // level of a page kept inserting into the container while its placeholder\n // sat in the screen, and the browser threw \"insertBefore: the node before\n // which the new node is to be inserted is not a child of this node\" -- the\n // page went blank the first time a top-level condition changed. The\n // if/else chain has always inserted at its placeholder's parent; :if and\n // :for now do the same. Hidden nodes registered on the old parent (#1954)\n // follow, so a later disposal walk of the new one still finds them.\n function followPlaceholder(placeholder, parent, nodes) {\n var now = placeholder.parentNode;\n if (!now || now === parent) return parent;\n var held = parent && parent.__stx_detached_if;\n if (held && nodes) {\n nodes.forEach(function(node) {\n if (!held.has(node)) return;\n held.delete(node);\n if (!now.__stx_detached_if) now.__stx_detached_if = new Set();\n now.__stx_detached_if.add(node);\n });\n }\n return now;\n }\n";
2
+ export declare const SIGNALS_LOOP_ROW_RUNTIME: string;
@@ -1,2 +1,2 @@
1
1
  /** Manifest-driven browser and native hydration for the generated client runtime. */
2
- export declare const SIGNALS_MANIFEST_HYDRATION_RUNTIME = " /**\n * Bind what the server said carries a binding, instead of looking for it.\n *\n * The walk exists because the runtime does not know where the bindings are.\n * The server does -- it rendered them -- so when it ships that list the\n * runtime stops searching: resolve each id, bind that element, never touch\n * its children. An element with no bindings is never visited at all.\n *\n * This is the piece a native host needs. A view hierarchy has no attributes\n * to read and no selector to match, so discovery cannot happen there; handed\n * the list, it does not have to. On the DOM the ids resolve by attribute,\n * which is one query per entry rather than a full traversal.\n *\n * Absent a manifest nothing changes: the walk is still the default, and a\n * page that ships no list hydrates exactly as it did.\n */\n function processFromManifest(root, scope, manifest, resolvedNodes) {\n // Arrays have an entries() method too. Prefer the array itself before\n // accepting the compiled document shape { entries: [...] }.\n var entries = Array.isArray(manifest)\n ? manifest\n : (manifest && Array.isArray(manifest.entries) ? manifest.entries : null);\n if (!entries || !entries.length || (!root && !resolvedNodes)) return false;\n for (var i = 0; i < entries.length; i++) {\n var entry = entries[i];\n var id = entry && entry.id;\n if (id === undefined || id === null) continue;\n // Native compilation already has stable handles for every manifest id.\n // Accept those handles directly so a non-DOM host never needs selectors\n // or an attribute walk. The browser keeps its existing lookup fallback.\n var node = resolvedNodes\n ? (typeof resolvedNodes.get === 'function' ? resolvedNodes.get(id) : resolvedNodes[id])\n : null;\n if (!node && root) {\n node = root.getAttribute && root.getAttribute('data-stx-b') === String(id)\n ? root\n : (root.querySelector ? root.querySelector('[data-stx-b=\"' + id + '\"]') : null);\n }\n if (!node) continue;\n // A structural binding can detach its source before a later manifest\n // entry reaches one of that source's children. Native handles expose\n // this state directly; do not register effects or handlers for a view\n // that no longer exists in the host tree. Browser hydration keeps its\n // existing behaviour because it does not pass resolvedNodes here.\n if (resolvedNodes && node.__stxId !== undefined && node.isConnected === false) continue;\n processElement(node, scope, true);\n }\n return true;\n }\n\n // Bind a precompiled host tree without waiting for DOMContentLoaded. Native\n // passes its manifest id to node-handle table; browser hydration continues\n // through the document-ready path below. The same state, effect, expression,\n // event and host implementations are used by both.\n function hydrateHost(root, setup, manifest, resolvedNodes) {\n var mountStart = mountCallbacks.length;\n var destroyStart = destroyCallbacks.length;\n var outerSink = activeDestroySink;\n activeDestroySink = null;\n var values;\n try { values = typeof setup === 'function' ? setup() : setup; }\n finally { activeDestroySink = outerSink; }\n var localMountHooks = mountCallbacks.splice(mountStart);\n var localDestroyHooks = destroyCallbacks.splice(destroyStart);\n var scope = Object.assign({ $refs: {} }, values || {});\n var disposeEffects = trackEffects(function() {\n processFromManifest(root, scope, manifest, resolvedNodes);\n });\n runMountCallbacks(localMountHooks, localDestroyHooks);\n var mounted = true;\n return function disposeHost() {\n if (!mounted) return;\n mounted = false;\n disposeEffects();\n var hooks = localDestroyHooks.splice(0, localDestroyHooks.length);\n for (var i = 0; i < hooks.length; i++) {\n try { hooks[i](); }\n catch (e) { console.warn('[stx] native destroy error:', e); }\n }\n };\n }\n";
2
+ export declare const SIGNALS_MANIFEST_HYDRATION_RUNTIME: string;
@@ -1,2 +1,2 @@
1
1
  /** Two-way form model binding for the generated client runtime. */
2
- export declare const SIGNALS_MODEL_RUNTIME = " function bindModel(el, expr, passedScope = componentScope, attrName = '@model') {\n if (el.__stx_model_bound) return;\n el.__stx_model_bound = true;\n const tag = el.tagName.toLowerCase();\n const type = el.type;\n const modifiers = attrName.split('.').slice(1);\n const capturedScope = { ...globalHelpers, ...passedScope, ...(findElementScope(el) || {}) };\n const coerceValue = (value) => {\n var next = value;\n if (modifiers.includes('trim') && typeof next === 'string') next = next.trim();\n if (modifiers.includes('number') && next !== '') {\n var numeric = Number(next);\n if (!Number.isNaN(numeric)) next = numeric;\n }\n return next;\n };\n\n const getValue = () => {\n var direct = capturedScope[expr];\n if (direct && typeof direct === 'function' && (direct._isSignal || direct._isDerived))\n return direct();\n try {\n var unwrapScope = createExpressionAutoUnwrapProxy(capturedScope, expr);\n var fn = __stxCompileScoped(unwrapScope, [], 'return (' + expr + ')');\n return fn(...__stxArgs(fn, unwrapScope));\n }\n catch (e) {\n if (!(e instanceof ReferenceError) && !(e instanceof TypeError)) console.warn('[STX] ' + attrName + ' get error:', expr, e);\n return '';\n }\n };\n const setValue = (val) => {\n try {\n if (capturedScope[expr] && capturedScope[expr]._isSignal) {\n capturedScope[expr].set(val);\n }\nelse {\n // Write through the SAME auto-unwrap proxy the read path uses.\n //\n // This used to destructure the scope into plain parameters, so an\n // lvalue like store.title assigned onto the raw object and REPLACED\n // the signal with a raw string. Everything else bound to that signal\n // stopped updating, its .set was gone so the next write threw\n // TypeError, and nothing warned \u2014 the field the user typed into was\n // the only thing on the page that still looked right (#1883).\n //\n // The proxy's set trap already did the correct thing (call .set on a\n // signal-valued property) and was simply never reached from here.\n // Routing through it also drops the old requirement that every scope\n // key be a valid identifier, since nothing is destructured now.\n var writeScope = createModelWriteProxy(capturedScope);\n var writeFn = __stxCompile(['__scope__', '__v__'], 'with(__scope__) { ' + expr + ' = __v__ }');\n writeFn(writeScope, val);\n }\n }\ncatch (e) {\n if (!(e instanceof ReferenceError) && !(e instanceof TypeError)) console.warn('[STX] ' + attrName + ' set error:', expr, e);\n }\n };\n\n if (tag === 'input' && type === 'checkbox') {\n var syncCheckbox = () => {\n var current = getValue();\n el.checked = Array.isArray(current)\n ? current.some(function(item) { return String(item) === String(el.value); })\n : Boolean(current);\n };\n el.__stx_model_sync = syncCheckbox;\n effect(syncCheckbox);\n stxHost.listen(el, 'change', () => {\n var current = getValue();\n if (!Array.isArray(current)) {\n setValue(el.checked);\n return;\n }\n\n var checkboxValue = coerceValue(el.value);\n var next = current.filter(function(item) { return String(item) !== String(checkboxValue); });\n if (el.checked) next.push(checkboxValue);\n setValue(next);\n });\n }\n else if (tag === 'input' && type === 'radio') {\n var syncRadio = () => { el.checked = String(getValue()) === String(el.value); };\n el.__stx_model_sync = syncRadio;\n effect(syncRadio);\n stxHost.listen(el, 'change', () => {\n if (el.checked) setValue(coerceValue(el.value));\n });\n }\n else if (tag === 'select') {\n // Same equality guard as the text branch. Harmless here \u2014 a select has\n // no caret \u2014 but an unconditional write is still a needless DOM mutation\n // on every signal change, and the inconsistency invites the text-branch\n // bug being reintroduced by copying this one (#1799).\n var syncSelect = () => { var next = getValue() ?? ''; if (el.value !== next) el.value = next; };\n el.__stx_model_sync = syncSelect;\n effect(syncSelect);\n if (!el.__stx_model_observer && typeof window.MutationObserver !== 'undefined') {\n el.__stx_model_observer = new window.MutationObserver(syncSelect);\n el.__stx_model_observer.observe(el, {\n childList: true,\n subtree: true,\n attributes: true,\n attributeFilter: ['value'],\n });\n el.__stx_destroy = el.__stx_destroy || [];\n el.__stx_destroy.push(function() {\n if (el.__stx_model_observer) el.__stx_model_observer.disconnect();\n el.__stx_model_observer = null;\n });\n }\n stxHost.listen(el, 'change', () => setValue(coerceValue(el.value)));\n }\nelse {\n // Writing el.value moves the text cursor to the END of the control, and\n // typing forms a loop: input -> setValue -> the signal changes -> this\n // effect re-runs -> the write. So every keystroke reset the caret\n // (stacksjs/stx#1799).\n //\n // Invisible while appending at the end of a field, which is why a login\n // form with x-model felt fine and a textarea people actually edit did\n // not. Worse inside :for, where key-based reuse updates the item signal\n // on reuse (#1669) and re-evaluates the reused row's bindings on every\n // character.\n //\n // The equality guard alone fixes typing, because the value this effect\n // computes IS the value just typed. The offset is preserved as well for\n // the case the guard cannot cover: a value that legitimately changed\n // from elsewhere while the field is focused \u2014 a formatter rewriting\n // input, a remote sync.\n effect(() => {\n var next = getValue() ?? '';\n if (el.value === next) return;\n var active = typeof document !== 'undefined' && document.activeElement === el;\n var start = null;\n var end = null;\n if (active) {\n // selectionStart throws on input types that do not support\n // selection (number, email, date), so it cannot be assumed present.\n try { start = el.selectionStart; end = el.selectionEnd; }\n catch (e) { start = null; end = null; }\n }\n el.value = next;\n if (active && start !== null && typeof el.setSelectionRange === 'function') {\n // Clamp: the incoming value may be shorter than the old offset.\n try { el.setSelectionRange(Math.min(start, next.length), Math.min(end == null ? start : end, next.length)); }\n catch (e) { /* type does not support selection */ }\n }\n });\n stxHost.listen(el, modifiers.includes('lazy') ? 'change' : 'input', () => setValue(coerceValue(el.value)));\n }\n\n el.removeAttribute(attrName);\n }\n";
2
+ export declare const SIGNALS_MODEL_RUNTIME: string;
@@ -1 +1 @@
1
- export declare const SIGNALS_MOUNT_RUNTIME = " mountEl: function(selector, setupFn) {\n function doMount() {\n var root = document.querySelector(selector);\n if (!root) { console.warn('[stx] mountEl: element not found:', selector); return; }\n\n // Set component context for defineProps/defineEmits (Phase 4)\n var prevProps = window.__STX_CURRENT_PROPS__;\n var prevEl = window.__STX_CURRENT_ELEMENT__;\n var propsAttr = root.getAttribute && root.getAttribute('data-stx-props');\n window.__STX_CURRENT_PROPS__ = root.__stx_props || (propsAttr ? JSON.parse(propsAttr) : {});\n window.__STX_CURRENT_ELEMENT__ = root;\n\n var mountStart = mountCallbacks.length;\n var destroyStart = destroyCallbacks.length;\n\n // The setup's hooks are collected off the global queues below, so an\n // outer flush's destroy sink must not catch them first (see mount).\n var outerSink = activeDestroySink;\n activeDestroySink = null;\n var scope;\n try { scope = setupFn(); }\n finally { activeDestroySink = outerSink; }\n\n // Restore previous context (supports nested components)\n window.__STX_CURRENT_PROPS__ = prevProps;\n window.__STX_CURRENT_ELEMENT__ = prevEl;\n\n var localMountHooks = mountCallbacks.splice(mountStart);\n var localDestroyHooks = destroyCallbacks.splice(destroyStart);\n\n if (typeof scope === 'object' && scope !== null) {\n scope.$el = root;\n scope.$refs = scope.$refs || {};\n root.__stx_scope = scope;\n }\n\n var disposeEffects = trackEffects(function() {\n processElement(root, { ...componentScope, ...(scope || {}) });\n });\n root.__stx_disposers = disposeEffects;\n\n root.removeAttribute('x-cloak');\n root.querySelectorAll('[x-cloak]').forEach(function(el) { el.removeAttribute('x-cloak'); });\n\n // Through runMountCallbacks, so an onDestroy called inside one of\n // them lands here too rather than on the global queue (#1958).\n runMountCallbacks(localMountHooks, localDestroyHooks);\n\n root.__stx_destroy = localDestroyHooks;\n }\n\n if (document.readyState === 'loading') {\n mountQueue.push(doMount);\n }\nelse {\n doMount();\n }\n },\n mount: function(setupFn) {\n console.log('[mount] called');\n // Capture script reference synchronously (only valid during execution)\n var scriptEl = document.currentScript;\n\n function doMount() {\n // Auto-mount scripts are emitted after their component template. Other\n // generated helper scripts can sit between the rendered root and this\n // script, so walk past script/style siblings before selecting the root.\n // Router-injected page scripts are marked data-stx-page and must use the\n // content-container fallback below instead.\n var isSpaPageScript = scriptEl && scriptEl.hasAttribute\n && scriptEl.hasAttribute('data-stx-page')\n && !scriptEl.hasAttribute('data-stx-positioned');\n var root = null;\n if (scriptEl && !isSpaPageScript) {\n var previous = scriptEl.previousElementSibling;\n while (previous && (previous.tagName === 'SCRIPT' || previous.tagName === 'STYLE'))\n previous = previous.previousElementSibling;\n\n var next = scriptEl.nextElementSibling;\n while (next && (next.tagName === 'SCRIPT' || next.tagName === 'STYLE'))\n next = next.nextElementSibling;\n\n root = previous || next || scriptEl.parentElement;\n }\n\n // SPA fallback: during router navigation, script is appended to body>\n // (not inside the content container), so nextElementSibling won't find the page content.\n // Only use fallback when we genuinely couldn't find a suitable root element.\n // Do NOT fallback just because the script is in body> \u2014 layout scripts in body>\n // with valid siblings (e.g. sidebar <aside>) should use those siblings as root.\n\n // An x-data root that initScope has not claimed yet is not ours to mount.\n //\n // The element carries its own state expression and the reactive runtime\n // owns it; data-stx-scope is on it from the server, but the id is not\n // in stx._scopes until initScope runs, which on a navigation happens\n // later in the stx:load handler. Mounting it in the meantime binds its\n // whole subtree against whatever scope the mounting script brought.\n //\n // That is what a layout script did after every SPA navigation. Its own\n // re-executed script now lands inside the content container next to the\n // incoming page, so previousElementSibling resolved to the *page's*\n // x-data root; mount() adopted it and ran processElement over it with the\n // sidebar's scope. Every :for template inside was consumed against a\n // scope holding none of the page's data, and bindFor replaces each\n // template with its stx-for anchor on that single pass \u2014 so the markup a\n // retry needed was gone, and the effect had read no signal to re-run on.\n // The list stayed empty for the life of the page while its state sat\n // fully populated beside it. Cold loads never hit it: there the page's\n // own script mounts first, with the right scope.\n //\n // Registered scopes are left alone, so an element the reactive runtime\n // has already initialised keeps whatever behaviour it had.\n function awaitingReactiveInit(el) {\n if (!el || !el.hasAttribute || !el.hasAttribute('data-stx-xdata'))\n return false;\n var id = el.getAttribute('data-stx-scope');\n return !(id && window.stx && window.stx._scopes && window.stx._scopes[id]);\n }\n\n var needsFallback = !root || root === document.body\n || (root && root.tagName === 'SCRIPT')\n || awaitingReactiveInit(root);\n if (needsFallback) {\n var routerOpts = window.STX_ROUTER_OPTIONS || window.__stxRouterConfig || {};\n var container = document.querySelector('[data-stx-content]')\n || document.querySelector('[data-stx-router-container]')\n || (routerOpts.container ? document.querySelector(routerOpts.container) : null)\n || document.querySelector('main')\n || document.querySelector('#content');\n if (container) {\n // Use the container itself as root \u2014 process ALL content inside it\n root = container;\n // But if a specific child is already mounted, find first unmounted one instead\n var hasMount = false;\n var children = container.children;\n for (var ci = 0; ci < children.length; ci++) {\n if (children[ci].__stx_scope) { hasMount = true; break; }\n }\n if (hasMount) for (var ci = 0; ci < children.length; ci++) {\n var candidate = children[ci];\n if (candidate.__stx_scope || candidate.tagName === 'SCRIPT') continue;\n if (awaitingReactiveInit(candidate)) continue;\n root = candidate;\n break;\n }\n }\n }\n\n // The fallback can still land on one (a container whose only unmounted\n // child is the incoming page). Processing the container instead is safe:\n // processElement skips [data-stx-scope] children, so the reactive\n // runtime keeps its subtree and binds it with the right scope.\n if (awaitingReactiveInit(root)) {\n var reactiveOwnerParent = root.parentElement;\n root = reactiveOwnerParent && reactiveOwnerParent !== document.body ? reactiveOwnerParent : null;\n }\n\n if (!root) { console.warn('[stx] mount: no root element found'); return; }\n\n // Set component context for defineProps/defineEmits (Phase 4)\n var prevProps = window.__STX_CURRENT_PROPS__;\n var prevEl = window.__STX_CURRENT_ELEMENT__;\n var propsAttr = root.getAttribute && root.getAttribute('data-stx-props');\n window.__STX_CURRENT_PROPS__ = root.__stx_props || (propsAttr ? JSON.parse(propsAttr) : {});\n window.__STX_CURRENT_ELEMENT__ = root;\n\n // Track lifecycle hooks registered during setup\n var mountStart = mountCallbacks.length;\n var destroyStart = destroyCallbacks.length;\n\n // Run setup function \u2014 returns scope object with declarations\n //\n // With no outer destroy sink (#1958). This can run inside another\n // component's onMount, where runMountCallbacks has pointed onDestroy at\n // THAT component's queue. The setup's own teardown (a composable such\n // as useEventListener registers its removal with onDestroy) must land\n // on the global queue, where the splice below collects it for this\n // root. Otherwise it belonged to the outer component and outlived this\n // root: mounted on a :for row, removing the row left its listener in.\n var outerSink = activeDestroySink;\n activeDestroySink = null;\n var scope;\n try { scope = setupFn(); }\n finally { activeDestroySink = outerSink; }\n console.log('[mount] root:', root.tagName, 'scope keys:', scope ? Object.keys(scope).slice(0, 10) : 'null');\n\n // Restore previous context (supports nested components)\n window.__STX_CURRENT_PROPS__ = prevProps;\n window.__STX_CURRENT_ELEMENT__ = prevEl;\n\n // Capture mount/destroy hooks added during setup\n var localMountHooks = mountCallbacks.splice(mountStart);\n var localDestroyHooks = destroyCallbacks.splice(destroyStart);\n\n // Register scope\n if (typeof scope === 'object' && scope !== null) {\n scope.$el = root;\n scope.$refs = scope.$refs || {};\n root.__stx_scope = scope; // Store isolated scope on element\n Object.assign(componentScope, scope); // Keep for backwards compat\n }\n\n // Walk DOM and bind directives, tracking effects for cleanup\n var disposeEffects = trackEffects(function() {\n processElement(root, { ...componentScope, ...(scope || {}) });\n });\n root.__stx_disposers = disposeEffects;\n\n // Remove x-cloak after bindings are applied (prevents FOUC)\n root.removeAttribute('x-cloak');\n root.querySelectorAll('[x-cloak]').forEach(function(el) { el.removeAttribute('x-cloak'); });\n\n // Fire mount hooks\n // Through runMountCallbacks, so an onDestroy called inside one of\n // them lands here too rather than on the global queue (#1958).\n runMountCallbacks(localMountHooks, localDestroyHooks);\n\n // Store cleanup on element for auto-destroy\n root.__stx_destroy = localDestroyHooks;\n }\n\n var isRoutedMount = scriptEl && scriptEl.hasAttribute\n && scriptEl.hasAttribute('data-stx-page');\n if (document.readyState === 'loading' || isRoutedMount) {\n mountQueue.push(doMount);\n }\nelse {\n doMount();\n }\n }";
1
+ export declare const SIGNALS_MOUNT_RUNTIME: string;
@@ -1,2 +1,2 @@
1
1
  /** Client-side navigation, route params, and search params runtime. */
2
- export declare const SIGNALS_NAVIGATION_RUNTIME = " // ==========================================================================\n // Navigation API\n // ==========================================================================\n\n // Second argument is an options object: { replace, reload, instant }.\n //\n // It used to be a bare forceReload boolean while the shipped declaration\n // promised { replace?: boolean } \u2014 so the one call the type system invited,\n // navigate(url, { replace: true }), took the truthy branch and did a full\n // document load that PUSHED a history entry: the opposite of replace, at the\n // cost of the SPA router, with no error (#1807).\n //\n // A bare boolean is still accepted and still means \"full reload\", because\n // that was the real shipped behaviour and docs and examples contain it.\n function navigate(url, options) {\n var opts = (options && typeof options === 'object') ? options : { reload: !!options };\n var replace = !!opts.replace;\n var reload = !!(opts.reload || opts.forceReload);\n if (!reload && window.stxRouter && typeof window.stxRouter.navigate === 'function') {\n var routed = { replace: replace };\n if (opts.instant) routed.instant = true;\n window.stxRouter.navigate(url, routed);\n return;\n }\n if (replace) window.location.replace(url);\n else window.location.href = url;\n }\n\n // Re-run the CURRENT route against the server and swap the result, keeping\n // every client signal on the page alive.\n //\n // The router grew refresh()/invalidate() for this, but they lived only on\n // window.stxRouter \u2014 nothing in the authoring surface reached them, so a\n // <script client> block still had no way to say \"the mutation changed what\n // the server rendered\". Apps kept calling location.reload() and threw away\n // the state the SPA exists to preserve. See #1850.\n //\n // Degrades to a real reload when the router is absent (a page that never\n // booted it, or a mid-boot call), mirroring how navigate() falls through to\n // window.location.\n function refresh() {\n if (window.stxRouter && typeof window.stxRouter.refresh === 'function')\n return window.stxRouter.refresh();\n window.location.reload();\n return Promise.resolve(false);\n }\n\n // Expire a cached route so the NEXT visit re-fetches it, without navigating\n // now. Pairs with refresh(): refresh the page you are on, invalidate the ones\n // your mutation also changed.\n function invalidateRoute(url) {\n if (window.stxRouter && typeof window.stxRouter.invalidate === 'function')\n window.stxRouter.invalidate(url);\n }\n\n function goBack() { window.history.back(); }\n function goForward() { window.history.forward(); }\n\n // Route params \u2014 set by server injection or parsed from URL on client navigation\n var _routeParams = state({});\n\n // setRouteParams: called by the server-injected script to set initial params\n function setRouteParams(params) {\n var nextParams = params || {};\n _routeParams.set(nextParams);\n window.__stx_rp = nextParams;\n if (window.stx) window.stx._rp = nextParams;\n }\n\n // Listen for SPA navigation to update params\n window.addEventListener('stx:navigate', function(e) {\n // The destination fragment's data-stx-route-params script runs after this\n // event and before stx:load. Reset first so a static route can never inherit\n // params from the dynamic route that preceded it.\n var nextParams = e.detail\n && Object.prototype.hasOwnProperty.call(e.detail, 'params')\n ? e.detail.params\n : {};\n setRouteParams(nextParams);\n });\n\n // Apply any server-injected params (set before runtime loaded)\n if ((window.stx && window.stx._rp) || window.__stx_rp) {\n _routeParams.set(window.stx?._rp || window.__stx_rp);\n }\n\n function useRoute() {\n return {\n get path() { return window.location.pathname; },\n get fullPath() { return window.location.pathname + window.location.search + window.location.hash; },\n get hash() { return window.location.hash; },\n get query() {\n var params = {};\n new URLSearchParams(window.location.search).forEach(function(v, k) { params[k] = v; });\n return params;\n },\n get params() { return _routeParams(); }\n };\n }\n\n // Exported from src/runtime.ts, whose whole stated purpose is client-facing\n // APIs that hide window internals \u2014 but never published on window.stx, so a\n // client script importing them destructured undefined and threw on use. The\n // capability was always here behind useRoute().params; only the documented\n // names were unreachable (stacksjs/stx#1843).\n function useRouteParams() {\n return _routeParams();\n }\n\n function useRouteParam(name, fallback) {\n var value = _routeParams()[name];\n return value === undefined ? fallback : value;\n }\n\n function keptHistoryState(wasPushed) {\n var current = window.history.state;\n if (!current || typeof current !== 'object') return wasPushed ? { __stxPushed: true } : {};\n var copy = {};\n for (var key in current) copy[key] = current[key];\n return copy;\n }\n function useSearchParams() {\n var params = state(Object.fromEntries(new URLSearchParams(window.location.search)));\n var syncFromUrl = function() {\n params.set(Object.fromEntries(new URLSearchParams(window.location.search)));\n };\n window.addEventListener('popstate', syncFromUrl);\n window.addEventListener('stx:navigate', syncFromUrl);\n // Own-property reads only. The backing object comes from Object.fromEntries,\n // so it inherits Object.prototype \u2014 an unguarded params()[key] returned a\n // FUNCTION for 'toString', 'constructor', 'valueOf' and friends, which is\n // neither a string nor undefined and matches no declared return type.\n var own = function(key) {\n var current = params();\n return Object.prototype.hasOwnProperty.call(current, key);\n };\n // pushState by default; replaceState when the caller asks for it (#1825).\n //\n // The canonical reason to delete a param is to CONSUME a one-shot value \u2014\n // an OAuth callback result, ?checkout=success, a flash token \u2014 and the\n // point of consuming it is that it must not survive a Back press. Under\n // pushState the pre-delete URL, the one still carrying the param, becomes\n // the previous entry, so Back replays the callback and whatever consuming\n // it triggered runs again.\n //\n // Default stays pushState so nothing that works today changes, and the\n // option is spelled { replace } to match navigate(), which already takes it.\n var commit = function(url, options) {\n // A plain truthy read of the replace property looks equivalent and is\n // not: it asks whether the value HAS a replace property, and every string\n // has String.prototype.replace \u2014 so delete(key, 'push') would have\n // replaced, the exact opposite of what it reads as. Requiring an object\n // also keeps this identical to the module implementation in\n // composables/use-router.ts; with optional chaining alone the two\n // disagreed on the empty string, which short-circuits in one and hits\n // String.prototype.replace in the other.\n //\n // NB: no backticks anywhere in this block. This runtime is assembled as a\n // template literal, so a backtick in a COMMENT ends the string and the\n // rest of the runtime is parsed as code.\n var replace = !!(options && typeof options === 'object' && options.replace);\n // Pushed entries are marked as the router marks them, and a replaced\n // one stays what it was, so Back knows whether it stays in the app.\n var wasPushed = !!(window.history.state && window.history.state.__stxPushed);\n // A replaced entry keeps the state it had: the router's scroll token,\n // its depth and tab are in there, and an entry stripped of them was\n // restored to the top on Back and miscounted by the tab bar.\n if (replace)\n window.history.replaceState(keptHistoryState(wasPushed), '', url);\n else\n window.history.pushState({ __stxPushed: true }, '', url);\n syncFromUrl();\n };\n return {\n data: params,\n get: function(key) { return own(key) ? params()[key] : undefined; },\n has: own,\n set: function(key, value, options) {\n var url = new URL(window.location.href);\n url.searchParams.set(key, value);\n commit(url, options);\n },\n // delete and has were DECLARED but absent, so the compiler endorsed calls\n // that threw in the browser; setAll and data were present but undeclared\n // (#1806). Deleting writes history the same way set does, for consistency.\n 'delete': function(key, options) {\n var url = new URL(window.location.href);\n url.searchParams['delete'](key);\n commit(url, options);\n },\n setAll: function(obj, options) {\n var url = new URL(window.location.href);\n Object.keys(obj).forEach(function(k) { url.searchParams.set(k, obj[k]); });\n commit(url, options);\n }\n };\n }\n";
2
+ export declare const SIGNALS_NAVIGATION_RUNTIME: string;
@@ -1,2 +1,2 @@
1
1
  /** Change notification shared by state, derived and reactive objects in the client runtime. */
2
- export declare const SIGNALS_NOTIFY_RUNTIME = " // ==========================================================================\n // Notify\n // ==========================================================================\n\n // Gather the effects a change reaches, walking through derived values.\n function collectSubscribers(subscribers, into) {\n subscribers.forEach(function(sub) {\n if (sub._stxCollect) sub._stxCollect(into);\n else into.add(sub);\n });\n }\n\n // Two phases: mark every derived value on the way stale and gather the\n // effects reached, then run each once. Running them as found ran an effect\n // that reads a signal both directly and through a derived twice for one\n // change, the first time against the derived's old value.\n function notifySubscribers(subscribers) {\n if (isBatching) {\n collectSubscribers(subscribers, pendingEffects);\n return;\n }\n const reached = new Set();\n collectSubscribers(subscribers, reached);\n reached.forEach(function(e) { e(); });\n }\n";
2
+ export declare const SIGNALS_NOTIFY_RUNTIME: string;
@@ -1,2 +1,2 @@
1
1
  /** Optimistic state overlay used by the generated client runtime. */
2
- export declare const SIGNALS_OPTIMISTIC_RUNTIME = " // ==========================================================================\n // Optimistic State (useOptimistic) \u2014 stacksjs/stx#1742\n // ==========================================================================\n // Mirrors signals-api.ts useOptimistic. Shows base + pending actions while an\n // async action is in flight; the overlay is discarded the moment base changes\n // (server confirmed). Returns [optimistic, addOptimistic]. addOptimistic\n // returns a settle() to roll back; pass a promise as the 2nd arg to auto-settle.\n function useOptimistic(base, reducer) {\n var readBase = (typeof base === 'function') ? base : function() { return base; };\n var pending = state([]);\n var optimistic = derived(function() {\n return pending().reduce(function(acc, entry) { return reducer(acc, entry.action); }, readBase());\n });\n var primed = false;\n effect(function() {\n readBase(); // track base only\n if (!primed) { primed = true; return; }\n if (peek(function() { return pending().length; })) pending.set([]);\n });\n function addOptimistic(action, settleWhen) {\n var entry = { action: action };\n pending.set(pending().concat([entry]));\n var settle = function() {\n var next = pending().filter(function(e) { return e !== entry; });\n if (next.length !== pending().length) pending.set(next);\n };\n if (settleWhen && typeof settleWhen.then === 'function') {\n Promise.resolve(settleWhen).then(settle, settle);\n }\n return settle;\n }\n return [optimistic, addOptimistic];\n }\n";
2
+ export declare const SIGNALS_OPTIMISTIC_RUNTIME: string;
@@ -1,2 +1,2 @@
1
1
  /** Shared overlay stack and modal facade used by the generated client runtime. */
2
- export declare const SIGNALS_OVERLAY_RUNTIME = " // \u2500\u2500 Overlay stack \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n //\n // One stack for everything that takes over the page: stxAlert/stxConfirm,\n // the runtime modal and drawer, @stacksjs/components' Dialog and Drawer, and\n // anything an app draws itself (window.stx.overlays). Each of those used to\n // keep its own listener, its own scroll lock and its own idea of whether it\n // was on top, so with one open over another a single Escape closed both, two\n // Tab traps fought over focus, and the first to close unlocked the page under\n // the one still open (stacksjs/stx#2057; #1998 fixed the same thing for the\n // confirm dialogs alone).\n //\n // Only the topmost overlay answers Escape and owns Tab. The page is locked\n // from the first open to the last close. Focus moves into an overlay when it\n // opens and back to whatever opened it when it closes.\n //\n // A popup - a menu, a listbox, a popover - goes on the same stack as a\n // non-modal layer (modal: false). It takes Escape while it is on top, so one\n // Escape inside a dialog closes the menu and leaves the dialog, but it does\n // not lock the page, trap Tab or move focus: those follow the topmost MODAL\n // layer. Each popup used to listen for Escape on the document itself, and\n // whichever listener was registered first won.\n var _overlays = [];\n var _overlayScroll = null;\n var _overlayInerted = [];\n var _overlayListening = false;\n var _OVERLAY_FOCUSABLE = 'a[href], button:not([disabled]), input:not([disabled]):not([type=\"hidden\"]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex=\"-1\"])';\n\n function _overlayTop() {\n return _overlays.length ? _overlays[_overlays.length - 1] : null;\n }\n\n // The layer that owns Tab and the page lock: the topmost modal one.\n function _overlayTopModal() {\n for (var i = _overlays.length - 1; i >= 0; i--) {\n if (_overlays[i].modal) return _overlays[i];\n }\n return null;\n }\n\n function _overlayIndex(id) {\n for (var i = 0; i < _overlays.length; i++) {\n if (_overlays[i].id === id) return i;\n }\n return -1;\n }\n\n // The panel is asked for, not held: a component's panel may not be rendered\n // yet on the frame it opens, and may be replaced while open.\n function _overlayPanel(entry) {\n var panel = entry && entry.panel;\n try {\n // A selector is looked up each time, like a function: the element it\n // names may be rendered after the overlay opens, or replaced while open.\n if (typeof panel === 'string') panel = document.querySelector(panel);\n else if (typeof panel === 'function') panel = panel();\n }\n catch (_e) { panel = null; }\n return panel || entry.root || null;\n }\n\n function _overlayShown(nodes) {\n return Array.prototype.filter.call(nodes, function(el) {\n return el.offsetParent !== null || el === document.activeElement;\n });\n }\n\n function _overlayFocusable(panel) {\n return _overlayShown(panel.querySelectorAll(_OVERLAY_FOCUSABLE));\n }\n\n // One listener for every overlay, in the bubble phase: a widget inside an\n // overlay that consumes Escape (a menu closing itself) calls preventDefault\n // and the overlay leaves it alone.\n function _overlayKey(e) {\n var top = _overlayTop();\n if (!top) return;\n if (e.key === 'Escape') {\n if (e.defaultPrevented || !top.onEscape) return;\n e.preventDefault();\n top.onEscape();\n return;\n }\n if (e.key !== 'Tab') return;\n var trap = _overlayTopModal();\n if (!trap) return;\n var panel = _overlayPanel(trap);\n if (!panel) return;\n var items = _overlayFocusable(panel);\n if (!items.length) {\n e.preventDefault();\n if (panel.focus) panel.focus();\n return;\n }\n var first = items[0];\n var last = items[items.length - 1];\n var active = document.activeElement;\n if (!panel.contains(active)) {\n e.preventDefault();\n (e.shiftKey ? last : first).focus();\n return;\n }\n if (e.shiftKey && active === first) {\n e.preventDefault();\n last.focus();\n }\n else if (!e.shiftKey && active === last) {\n e.preventDefault();\n first.focus();\n }\n }\n\n // Lock, listen and inert to match the stack after any change.\n function _overlaySync() {\n for (var i = 0; i < _overlayInerted.length; i++) {\n try { _overlayInerted[i].inert = false; }\n catch (_e) { /* element may be gone */ }\n }\n _overlayInerted = [];\n\n var top = _overlayTop();\n var modal = _overlayTopModal();\n if (!modal && _overlayScroll) {\n document.body.style.overflow = _overlayScroll.body;\n document.documentElement.style.overflow = _overlayScroll.html;\n document.body.style.paddingRight = _overlayScroll.pad;\n _overlayScroll = null;\n }\n if (!top) {\n if (_overlayScroll) {\n document.body.style.overflow = _overlayScroll.body;\n document.documentElement.style.overflow = _overlayScroll.html;\n document.body.style.paddingRight = _overlayScroll.pad;\n _overlayScroll = null;\n }\n if (_overlayListening) {\n document.removeEventListener('keydown', _overlayKey);\n _overlayListening = false;\n }\n return;\n }\n\n if (modal && !_overlayScroll) {\n _overlayScroll = {\n body: document.body.style.overflow,\n html: document.documentElement.style.overflow,\n pad: document.body.style.paddingRight\n };\n // The scrollbar's width comes back as padding, so the page does not jump\n // sideways when it disappears.\n var gap = window.innerWidth - document.documentElement.clientWidth;\n if (gap > 0) {\n var existing = Number.parseFloat(window.getComputedStyle(document.body).paddingRight) || 0;\n document.body.style.paddingRight = (existing + gap) + 'px';\n }\n document.body.style.overflow = 'hidden';\n document.documentElement.style.overflow = 'hidden';\n }\n if (!_overlayListening) {\n document.addEventListener('keydown', _overlayKey);\n _overlayListening = true;\n }\n\n // An overlay given a z-index stacks by the order it opened in, not by\n // where it sits in the document: one lifted into the body early (a sheet\n // mounted before the sheet it later opens over) drew underneath. Set on\n // every change, so what stays open closes up when one under it closes. A\n // closed overlay keeps its last value, so it slides away above the one\n // it was over.\n for (var z = 0; z < _overlays.length; z++) {\n var layer = _overlays[z];\n if (typeof layer.zIndex === 'number' && layer.root && layer.root.style) layer.root.style.zIndex = String(layer.zIndex + z);\n }\n\n // inert, rather than aria-hidden, takes the page behind out of the tab\n // order and the accessibility tree together (#1998). Only behind an\n // overlay that is a child of the body element - one the runtime appended,\n // or one an app lifted there - or one opened inside such an overlay (a\n // dialog in a sheet's content). An overlay rendered inside the page's own\n // markup would go inert with the page; its Tab trap is what holds it.\n var root = _overlayInertRoot(modal);\n if (root) {\n var kids = document.body.children;\n for (var k = 0; k < kids.length; k++) {\n var kid = kids[k];\n if (kid === root || kid.inert) continue;\n try {\n kid.inert = true;\n _overlayInerted.push(kid);\n }\n catch (_e) { /* inert unsupported; the Tab trap still holds */ }\n }\n }\n }\n\n // The child of the body that keeps the rest of the page inert while this\n // modal layer is on top: its own root when that is in the body, or the\n // root of the open overlay it sits inside. A dialog opened from a sheet's\n // content is not itself in the body, and the page behind the sheet used to\n // come back to the keyboard and screen readers while it was up.\n function _overlayInertRoot(modal) {\n if (!modal) return null;\n var el = modal.root || _overlayPanel(modal);\n while (el && el.parentNode && el.parentNode !== document.body) el = el.parentNode;\n if (!el || el.parentNode !== document.body) return null;\n if (el === modal.root) return el;\n for (var i = 0; i < _overlays.length; i++) {\n if (_overlays[i] !== modal && _overlays[i].root === el) return el;\n }\n return null;\n }\n\n // The next chance to act, whichever comes first: rAF is suspended in a\n // background tab, so a timer races it.\n function _overlaySoon(callback) {\n var done = false;\n var once = function() {\n if (done) return;\n done = true;\n callback();\n };\n if (typeof requestAnimationFrame === 'function') requestAnimationFrame(once);\n setTimeout(once, 32);\n }\n\n // Retried, because focus() on an element that is not displayed yet is a\n // silent no-op. Stops once the overlay has closed.\n function _overlayFocusIn(entry, attempts) {\n if (_overlayIndex(entry.id) === -1) return;\n var target = null;\n try { target = typeof entry.initialFocus === 'function' ? entry.initialFocus() : entry.initialFocus; }\n catch (_e) { target = null; }\n var panel = _overlayPanel(entry);\n // An [autofocus] that is not shown (behind a :show, a player in a\n // dialog that is showing something else) cannot take focus: skipped, or\n // focus went nowhere and the panel's first control never got it.\n if (!target && panel) target = _overlayShown(panel.querySelectorAll('[autofocus]'))[0] || _overlayFocusable(panel)[0] || panel;\n if (target && target.focus) target.focus();\n if (target && document.activeElement === target) return;\n if (attempts > 0) _overlaySoon(function() { _overlayFocusIn(entry, attempts - 1); });\n }\n\n var overlays = {\n /**\n * Put an overlay on top. Calling it again for an open id updates its\n * options and nothing else, so it is safe from an effect that re-runs.\n *\n * options: modal (default true; false for a popup, which takes Escape\n * while on top but does not lock, trap or move focus), panel (an element,\n * a selector, or a function returning one; focus stays inside it), root (the overlay's outermost element, if it is not the panel),\n * zIndex (a base: the root's z-index becomes it plus the overlay's place\n * in the stack, so a later overlay draws over an earlier one wherever it\n * sits in the document), onEscape (leave out for one that must be answered), initialFocus\n * (element or function; defaults to [autofocus], then the first focusable,\n * then the panel), opener (where focus goes back; defaults to whatever had\n * it), restoreFocus (default true).\n */\n open: function(id, options) {\n var opts = options || {};\n var at = _overlayIndex(id);\n if (at !== -1) {\n var existing = _overlays[at];\n for (var key in opts) {\n if (Object.prototype.hasOwnProperty.call(opts, key)) existing[key] = opts[key];\n }\n _overlaySync();\n return;\n }\n var isModal = opts.modal !== false;\n var entry = {\n id: id,\n modal: isModal,\n panel: opts.panel,\n root: opts.root || null,\n zIndex: typeof opts.zIndex === 'number' ? opts.zIndex : null,\n onEscape: opts.onEscape || null,\n initialFocus: opts.initialFocus || null,\n // A popup hands focus back itself, to its own trigger, and only when\n // focus was inside it; a modal layer always does.\n restoreFocus: opts.restoreFocus !== undefined ? opts.restoreFocus !== false : isModal,\n opener: opts.opener !== undefined ? opts.opener : document.activeElement\n };\n _overlays.push(entry);\n _overlaySync();\n // Synchronously first, so a caller that asserts focus straight after\n // opening sees it; then retried for a panel that is not displayed yet.\n // A popup keeps focus where its own keyboard handling puts it.\n if (isModal || opts.initialFocus) _overlayFocusIn(entry, 10);\n },\n /** Take an overlay off the stack, wherever it is in it. */\n close: function(id) {\n var at = _overlayIndex(id);\n if (at === -1) return;\n var wasTop = at === _overlays.length - 1;\n var entry = _overlays.splice(at, 1)[0];\n _overlaySync();\n // Only the overlay that had the keyboard gives it back. Closing one\n // underneath (its owner went away) must not pull focus out of the top.\n var opener = entry.opener;\n if (wasTop && entry.restoreFocus && opener && opener.isConnected !== false && typeof opener.focus === 'function') {\n try { opener.focus(); }\n catch (_e) { /* gone; nothing to give focus back to */ }\n }\n },\n /** Whether this overlay is the one that has the keyboard. */\n isTop: function(id) {\n var top = _overlayTop();\n return !!top && top.id === id;\n },\n /** Open overlay ids, outermost first. */\n list: function() {\n return _overlays.map(function(o) { return o.id; });\n }\n };\n\n // \u2500\u2500 Modal system \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n var modal = {\n open: function(id) {\n var el = document.querySelector('[data-stx-modal=\"' + id + '\"]');\n if (!el) { console.warn('[stx:modal] Modal \"' + id + '\" not found'); return; }\n el.style.display = 'flex';\n // Force reflow then animate\n void el.offsetHeight;\n el.setAttribute('data-stx-modal-open', '');\n // The lock, Escape for the topmost and the Tab trap come from the\n // overlay stack, shared with every other overlay (stacksjs/stx#2057).\n // Each modal used to bind its own Escape and set body overflow itself,\n // so two open closed together and the first to close unlocked the page.\n overlays.open('stx-modal:' + id, {\n panel: el,\n onEscape: el.getAttribute('data-close-escape') !== 'false' ? function() { modal.close(id); } : null\n });\n if (el.getAttribute('data-close-backdrop') !== 'false') {\n el.onclick = function(e) { if (e.target === el) modal.close(id); };\n }\n },\n close: function(id) {\n var el = document.querySelector('[data-stx-modal=\"' + id + '\"]');\n if (!el) return;\n el.removeAttribute('data-stx-modal-open');\n el.onclick = null;\n overlays.close('stx-modal:' + id);\n setTimeout(function() {\n if (!el.hasAttribute('data-stx-modal-open')) el.style.display = 'none';\n }, 200);\n },\n toggle: function(id) {\n var el = document.querySelector('[data-stx-modal=\"' + id + '\"]');\n if (el && el.hasAttribute('data-stx-modal-open')) modal.close(id);\n else modal.open(id);\n }\n };\n";
2
+ export declare const SIGNALS_OVERLAY_RUNTIME: string;
@@ -1,2 +1,2 @@
1
1
  /** Pipe expression parsing and execution for client template bindings. */
2
- export declare const SIGNALS_PIPE_RUNTIME = " // ==========================================================================\n // Pipe Syntax Support (Feature #2)\n // ==========================================================================\n\n // Parse and execute pipe expressions like \"value | fmt\" or \"value | truncate:20\"\n // Must distinguish single | (pipe) from || (logical OR) and ?? (nullish coalescing)\n function parsePipeExpression(expr, scope) {\n // Find pipe operators: single | that's not part of || or preceded by ?\n // We need to find | that is:\n // 1. Not preceded by | or ?\n // 2. Not followed by |\n // Use a manual scan to handle this correctly\n let pipeIndex = -1;\n let inString = false;\n let stringChar = '';\n let depth = 0; // Track parentheses/brackets depth\n\n for (let i = 0; i < expr.length; i++) {\n const char = expr[i];\n const prevChar = i > 0 ? expr[i - 1] : '';\n const nextChar = i < expr.length - 1 ? expr[i + 1] : '';\n\n // Handle string literals\n if ((char === '\"' || char === \"'\" || char === '`') && prevChar !== '\\\\') {\n if (!inString) {\n inString = true;\n stringChar = char;\n }\nelse if (char === stringChar) {\n inString = false;\n }\n continue;\n }\n\n if (inString) continue;\n\n // Track depth for parentheses and brackets\n if (char === '(' || char === '[' || char === '{') depth++;\n if (char === ')' || char === ']' || char === '}') depth--;\n\n // Only look for pipes at top level (depth 0)\n if (depth !== 0) continue;\n\n // Check for single pipe (not || and not ??)\n if (char === '|') {\n // Skip if it's || (logical OR)\n if (nextChar === '|') {\n i++; // Skip next |\n continue;\n }\n // Skip if preceded by | (second part of ||)\n if (prevChar === '|') continue;\n // Skip if preceded by ? (part of ??)\n if (prevChar === '?') continue;\n\n // Found a pipe operator\n pipeIndex = i;\n break;\n }\n }\n\n if (pipeIndex === -1) return null;\n\n const valueExpr = expr.slice(0, pipeIndex).trim();\n const pipeChain = expr.slice(pipeIndex + 1).trim();\n\n // Parse all pipes in the chain, being careful about || and ??\n const pipes = [];\n let currentPipe = '';\n inString = false;\n stringChar = '';\n depth = 0;\n\n for (let i = 0; i < pipeChain.length; i++) {\n const char = pipeChain[i];\n const prevChar = i > 0 ? pipeChain[i - 1] : '';\n const nextChar = i < pipeChain.length - 1 ? pipeChain[i + 1] : '';\n\n // Handle string literals\n if ((char === '\"' || char === \"'\" || char === '`') && prevChar !== '\\\\') {\n if (!inString) {\n inString = true;\n stringChar = char;\n }\nelse if (char === stringChar) {\n inString = false;\n }\n currentPipe += char;\n continue;\n }\n\n if (inString) {\n currentPipe += char;\n continue;\n }\n\n // Track depth\n if (char === '(' || char === '[' || char === '{') depth++;\n if (char === ')' || char === ']' || char === '}') depth--;\n\n // Check for pipe at top level\n if (depth === 0 && char === '|' && nextChar !== '|' && prevChar !== '|' && prevChar !== '?') {\n // End of current pipe, start new one\n if (currentPipe.trim()) {\n const parts = currentPipe.trim().split(':');\n pipes.push({\n name: parts[0].trim(),\n args: parts.slice(1).map(a => a.trim())\n });\n }\n currentPipe = '';\n }\nelse {\n currentPipe += char;\n }\n }\n\n // Add last pipe\n if (currentPipe.trim()) {\n const parts = currentPipe.trim().split(':');\n pipes.push({\n name: parts[0].trim(),\n args: parts.slice(1).map(a => a.trim())\n });\n }\n\n if (pipes.length === 0) return null;\n\n return { valueExpr, pipes };\n }\n\n function executePipeExpression(valueExpr, pipes, scope) {\n // First evaluate the base expression\n let value;\n try {\n const fn = __stxCompileScoped(scope, [], 'return ' + valueExpr);\n value = fn(...__stxArgs(fn, scope));\n }\ncatch (e) {\n if (!(e instanceof ReferenceError) && !(e instanceof TypeError)) console.warn('[STX] Pipe base expression error:', valueExpr, e);\n return '';\n }\n\n // Apply each pipe/filter\n for (const pipe of pipes) {\n const filterFn = scope[pipe.name] || globalHelpers[pipe.name];\n if (typeof filterFn === 'function') {\n try {\n // Parse args - they might be numbers, strings, or expressions\n const parsedArgs = pipe.args.map(arg => {\n // Try to parse as number\n if (/^-?\\d+(\\.\\d+)?$/.test(arg)) return Number(arg);\n // Try to parse as string (quoted)\n if (/^['\"].*['\"]$/.test(arg)) return arg.slice(1, -1);\n // Try to evaluate as expression in scope\n try {\n const fn = __stxCompileScoped(scope, [], 'return ' + arg);\n return fn(...__stxArgs(fn, scope));\n }\ncatch (e) {\n return arg;\n }\n });\n value = filterFn(value, ...parsedArgs);\n }\ncatch (e) {\n if (!(e instanceof ReferenceError) && !(e instanceof TypeError)) console.warn('[STX] Pipe filter error:', pipe.name, e);\n }\n }\nelse {\n console.warn('[STX] Unknown pipe/filter:', pipe.name);\n }\n }\n\n return value;\n }\n";
2
+ export declare const SIGNALS_PIPE_RUNTIME: string;
@@ -1,2 +1,2 @@
1
1
  /** Read and write proxies that preserve signal semantics in template scopes. */
2
- export declare const SIGNALS_PROXY_RUNTIME = " // ==========================================================================\n // Auto-unwrap Signals (Feature #1)\n // ==========================================================================\n\n // Create a proxy that auto-unwraps signals when accessed.\n // For stx stores (objects with _isStxStore), recursively wrap so nested\n // signal properties auto-unwrap too \u2014 this is what makes template\n // expressions like store.someSignal (no parens) and store.x === 'y'\n // resolve to the value. Action methods on the store pass through as\n // functions because they don't carry _isSignal/_isDerived markers.\n function createAutoUnwrapProxy(scope, preserveSignal) {\n return new Proxy(scope, {\n get(target, prop) {\n const val = target[prop];\n // If it's a signal or derived, call it to get the value\n if (val && typeof val === 'function' && (val._isSignal || val._isDerived)) {\n // Loop variables are implementation-detail signals so keyed rows can\n // update reactively. In template expressions they must behave like\n // their item value, including for objects with fields named value,\n // set, or subscribe. Otherwise item.value is mistaken for the\n // signal compatibility API and resolves to the whole item object.\n if (val._isStxLoopItem) return val();\n if (preserveSignal && preserveSignal(prop, val)) return val;\n return val();\n }\n // If it's an stx store, return a recursively-unwrapping wrapper so\n // store.signalProp resolves to the value in template expressions\n if (val && typeof val === 'object' && val._isStxStore) {\n return createAutoUnwrapProxy(val, preserveSignal);\n }\n return val;\n },\n set(target, prop, value) {\n const cur = target[prop];\n if (cur && typeof cur === 'function' && cur._isSignal && typeof cur.set === 'function') {\n cur.set(value);\n return true;\n }\n target[prop] = value;\n return true;\n }\n });\n }\n\n // A proxy for the WRITE side of x-model, kept separate from the read proxy\n // on purpose.\n //\n // The read proxy returns a plain object as-is, which is right for reading \u2014\n // ordinary data should stay ordinary. But it means an assignment lands on the\n // raw object, so a signal held there gets REPLACED by the typed value rather\n // than set (#1883). Descending through a write proxy instead keeps set-trap\n // semantics all the way down, so the signal at the end of any path is set.\n function createModelWriteProxy(target) {\n return new Proxy(target, {\n get(t, prop) {\n var val = t[prop];\n if (val && typeof val === 'function' && (val._isSignal || val._isDerived)) {\n // Descend INTO the signal's value: x-model=\"form.email\" over\n // state({email}) must reach the object, not stamp a property onto\n // the signal function itself.\n var inner = val();\n return (inner && typeof inner === 'object') ? createModelWriteProxy(inner) : inner;\n }\n if (val && typeof val === 'object') return createModelWriteProxy(val);\n return val;\n },\n set(t, prop, value) {\n var cur = t[prop];\n if (cur && typeof cur === 'function' && cur._isSignal && typeof cur.set === 'function') {\n cur.set(value);\n return true;\n }\n t[prop] = value;\n return true;\n },\n });\n }\n";
2
+ export declare const SIGNALS_PROXY_RUNTIME: string;
@@ -1,2 +1,2 @@
1
1
  /** Query and mutation composables used by the generated client runtime. */
2
- export declare const SIGNALS_QUERY_RUNTIME = " // ==========================================================================\n // Advanced Data Fetching (useQuery / useMutation)\n // ==========================================================================\n\n var _queryCache = {};\n // Requests currently in flight, keyed exactly like _queryCache. _queryCache\n // is written only after the body parses, so the whole in-flight window was a\n // cache miss and N components mounting together issued N identical requests\n // (#1869). Refcounted: a caller that loses interest must not cancel a\n // response another caller is still waiting on.\n var _queryInflight = {};\n var __stxQueryInstance = 0;\n\n // Suspense registry (#1742). A query created with { suspense: true } pushes\n // { el, loading, error } here at creation time (which runs during partial-scope\n // script execution, BEFORE the <Suspense> boundary inits on content-load).\n // Each boundary then CLAIMS the descendant entries for which it is the nearest\n // [data-stx-suspense] ancestor, and aggregates their loading/error signals.\n // Kept on the window (one registry per page) rather than a per-instance\n // closure so a boundary and the queries it claims agree even if the page\n // somehow has more than one runtime instance (e.g. across test files).\n function suspenseRegistry() {\n if (typeof window === 'undefined') return [];\n return window.__stx_suspense_registry || (window.__stx_suspense_registry = []);\n }\n function registerSuspense(loading, error) {\n var el = (typeof window !== 'undefined' && window.__STX_CURRENT_ELEMENT__) || null;\n suspenseRegistry().push({ el: el, loading: loading, error: error });\n }\n\n function useQuery(url, options) {\n options = options || {};\n var staleTime = options.staleTime || 0;\n var cacheTime = options.cacheTime || 300000; // 5 min default\n var cacheKey = options.cacheKey || (typeof url === 'function' ? null : url);\n // keep: the answer is kept on the device per account (setKeptScope, or\n // options.scope) and seeds the next visit synchronously, refreshed behind.\n // true keeps it under the query's key; a string names it.\n var keepKey = options.keep ? (typeof options.keep === 'string' ? options.keep : cacheKey) : null;\n var queryTarget = function() {\n var resolved = null;\n try { resolved = typeof url === 'function' ? url() : url; } catch (e) {}\n return { key: cacheKey || keepKey || resolved || '', url: resolved };\n };\n // What is shown is the last answer with the outbox's waiting writes on\n // top, so a change made offline is not undone by a refetch.\n var base = options.initialData || null;\n var seeded = keepKey ? __stxQueries.seed(keepKey, options.scope) : undefined;\n if (seeded) base = seeded.data;\n var data = state(seeded ? __stxQueries.overlay(queryTarget(), base) : base);\n var show = function(value) {\n base = value;\n data.set(__stxQueries.overlay(queryTarget(), value));\n };\n var answered = false;\n var loading = state(!seeded);\n // See useFetch: loading means \"nothing to show yet\", isFetching means \"a\n // request is open\" \u2014 including a background refresh, which is the case that\n // makes the distinction necessary (#1929).\n var isFetching = state(true);\n var error = state(null);\n var isStale = state(!!seeded);\n if (options.suspense) registerSuspense(loading, error);\n // Kept too large for a synchronous read: it arrives a moment later, and\n // shows unless an answer came first.\n if (keepKey && !seeded) {\n __stxQueries.restore(keepKey, options.scope).then(function(found) {\n if (!found || answered) return;\n show(found.data);\n loading.set(false);\n isStale.set(true);\n });\n }\n\n // Per-run AbortController: a newer run aborts the previous in-flight one and\n // onDestroy aborts the last, so a resolved request can't write into a\n // torn-down scope (#1871).\n var __stxAbort = null;\n // Identity, so dedup can tell \"another component wants this key\" from\n // \"this component asked again\". They must behave differently: joining is\n // right for the first, and wrong for the second \u2014 refetch() after a\n // mutation has to hit the network, not adopt the pre-mutation request that\n // happens to still be open (#1869).\n var __instanceId = ++__stxQueryInstance;\n // The shared entry this instance is currently attached to, so superseding\n // can release its claim without cancelling a request someone else joined.\n var __joined = null;\n\n // runOptions: { background: true } refreshes without touching loading or\n // clearing the current error. A poll must not flash a spinner over data\n // that is already on screen (#1929).\n var fetchData = async function(runOptions) {\n var background = !!(runOptions && runOptions.background);\n var resolvedUrl = typeof url === 'function' ? url() : url;\n if (!resolvedUrl) { if (!background) loading.set(false); isFetching.set(false); return; }\n var key = cacheKey || resolvedUrl;\n\n // Check cache\n var cached = _queryCache[key];\n if (cached && (Date.now() - cached.timestamp < staleTime)) {\n answered = true;\n show(cached.data);\n if (!background) loading.set(false);\n isFetching.set(false);\n isStale.set(false);\n if (options.onSuccess) options.onSuccess(cached.data);\n return;\n }\n\n // Stale-while-revalidate\n if (cached) {\n show(cached.data);\n isStale.set(true);\n }\n\n // Join a request ANOTHER instance already has open for this key. Not one\n // of our own: this instance calling refetch() means \"I want fresh data\",\n // and adopting its own pre-mutation request would silently return stale\n // data \u2014 so an own-instance run still supersedes, exactly as #1871 says.\n var shared = _queryInflight[key];\n if (shared && shared.owner !== __instanceId) {\n shared.refs++;\n __joined = shared;\n if (!background) loading.set(true);\n isFetching.set(true);\n if (!background) error.set(null);\n try {\n var joinedResult = await shared.promise;\n var joinedTransformed = options.transform ? options.transform(joinedResult) : joinedResult;\n answered = true;\n show(joinedTransformed);\n if (keepKey) __stxQueries.persist(keepKey, joinedTransformed, options.scope);\n if (background) error.set(null);\n isStale.set(false);\n if (options.onSuccess) options.onSuccess(joinedTransformed);\n }\n catch (e) {\n if (e && e.name === 'AbortError') return;\n error.set(e.message || 'Query failed');\n if (options.onError) options.onError(e);\n }\n finally {\n shared.refs--;\n if (__joined === shared) __joined = null;\n if (!background) loading.set(false);\n isFetching.set(false);\n }\n return;\n }\n\n // Superseding this instance's own run. Abort ONLY if nobody joined it \u2014\n // cancelling a request another component is waiting on would leave it\n // loading forever, which would turn #1871's fix into a worse bug.\n if (__stxAbort) {\n if (__joined && __joined.refs > 1) __joined.refs--;\n else __stxAbort.abort();\n }\n __joined = null;\n __stxAbort = (typeof AbortController !== 'undefined') ? new AbortController() : null;\n var __signal = __stxAbort ? __stxAbort.signal : undefined;\n if (!background) loading.set(true);\n isFetching.set(true);\n if (!background) error.set(null);\n try {\n var fetchOpts = { method: 'GET', headers: { 'Content-Type': 'application/json', ...__stxHeaders(options.headers) }, signal: __signal };\n // Published BEFORE it is awaited, so a caller starting in the same tick\n // finds it. The network part only \u2014 transform, cache write and\n // onSuccess stay per-caller, since each may transform differently.\n var netPromise = (async function() {\n var response = await __stxFetch('useQuery', resolvedUrl, fetchOpts);\n if (!response.ok) throw await __stxHttpError(response);\n return await response.json();\n })();\n var entry = { owner: __instanceId, refs: 1, controller: __stxAbort, promise: netPromise };\n _queryInflight[key] = entry;\n __joined = entry;\n // Cleared on settle, both ways. A settled entry left behind would turn\n // dedup into a permanent cache and no request for this key would ever\n // be issued again.\n var releaseEntry = function() { if (_queryInflight[key] === entry) delete _queryInflight[key]; };\n netPromise.then(releaseEntry, releaseEntry);\n\n var result = await netPromise;\n if (__signal && __signal.aborted) return;\n var transformed = options.transform ? options.transform(result) : result;\n answered = true;\n show(transformed);\n if (keepKey) __stxQueries.persist(keepKey, transformed, options.scope);\n if (background) error.set(null);\n isStale.set(false);\n _queryCache[key] = { data: transformed, timestamp: Date.now() };\n if (options.onSuccess) options.onSuccess(transformed);\n // Schedule cache eviction\n setTimeout(function() { delete _queryCache[key]; }, cacheTime);\n }\ncatch (e) {\n // A superseded/unmounted request rejects with AbortError \u2014 expected;\n // the run that superseded it owns the state (#1871).\n if (e && e.name === 'AbortError') return;\n error.set(e.message || 'Query failed');\n if (options.onError) options.onError(e);\n }\nfinally {\n if (!__signal || !__signal.aborted) {\n if (!background) loading.set(false);\n isFetching.set(false);\n }\n }\n };\n\n // A refetch nobody asked for does not set loading (see backgroundRun below).\n var backgroundRun = { background: true };\n\n if (options.immediate !== false) {\n // Seeded from the device: the kept copy is on screen, so the first\n // fetch refreshes it behind rather than putting a spinner over it.\n onMount(function() { return seeded ? fetchData(backgroundRun) : fetchData(); });\n }\n\n // The worker has a newer answer for this URL, or the outbox changed: a\n // write waiting on it is shown on top, and one that reached the server\n // stays shown until the refetch it triggers includes it.\n var unwatch = __stxQueries.watch({\n target: queryTarget,\n updated: function() {\n delete _queryCache[cacheKey || queryTarget().url];\n fetchData(backgroundRun);\n },\n outbox: function(sent) {\n if (sent) {\n base = __stxQueries.overlay(queryTarget(), base, sent.id);\n delete _queryCache[cacheKey || queryTarget().url];\n fetchData(backgroundRun);\n }\n show(base);\n }\n });\n onDestroy(unwatch);\n\n // A refetch nobody asked for does not set loading. Both of these refresh\n // data that is ALREADY on screen, so driving the first-load state from them\n // put a spinner over a populated view once a minute, forever \u2014 the reason a\n // polling view could not use this composable at all (#1929). Bind\n // isFetching for a subtle in-flight indicator.\n\n // refetchOnFocus \u2014 removed on destroy, like refetchInterval right below.\n // It used to add a listener and never remove it, so every instance leaked\n // one for the life of the page and each SPA navigation added more; every\n // stale listener still fired, refetching for components long gone (#1818).\n if (options.refetchOnFocus) {\n var onVisibility = function() {\n if (!document.hidden) fetchData(backgroundRun);\n };\n document.addEventListener('visibilitychange', onVisibility);\n onDestroy(function() { document.removeEventListener('visibilitychange', onVisibility); });\n }\n\n // refetchInterval: poll only while the tab is visible and (if given)\n // enabled holds; optionally stop after an error so a broken endpoint is\n // not hammered every interval in a backgrounded tab (#1870).\n if (options.refetchInterval) {\n var intervalId = setInterval(function() {\n if (typeof document !== 'undefined' && document.hidden) return;\n var en = options.enabled;\n if (typeof en === 'function' ? !en() : en === false) return;\n var p = fetchData(backgroundRun);\n if (options.stopOnError && p && typeof p.then === 'function') {\n p.then(function() { if (error()) clearInterval(intervalId); });\n }\n }, options.refetchInterval);\n onDestroy(function() { clearInterval(intervalId); });\n }\n\n // Abort an in-flight request when the owning scope is destroyed (#1871).\n onDestroy(function() { if (__stxAbort) __stxAbort.abort(); });\n\n return {\n data: data,\n loading: loading,\n isFetching: isFetching,\n error: error,\n isStale: isStale,\n refetch: fetchData,\n invalidate: function(runOptions) {\n var key = cacheKey || (typeof url === 'function' ? url() : url);\n delete _queryCache[key];\n return fetchData(runOptions);\n }\n };\n }\n\n function useMutation(url, options) {\n options = options || {};\n var data = state(null);\n var loading = state(false);\n var error = state(null);\n\n var mutate = async function(body) {\n loading.set(true);\n error.set(null);\n var previousData = data();\n\n // Optimistic update\n if (options.optimisticData) {\n var optimistic = typeof options.optimisticData === 'function' ? options.optimisticData(body) : options.optimisticData;\n data.set(optimistic);\n }\n\n try {\n var resolvedUrl = typeof url === 'function' ? url() : url;\n var fetchOpts = {\n method: options.method || 'POST',\n // A file upload is a FormData body. Stringifying it sent \"{}\", and\n // the browser has to write its own multipart Content-Type (the\n // boundary lives there), so raw bodies pass through untouched.\n headers: __stxRawBody(body) ? __stxHeaders(options.headers) : { 'Content-Type': 'application/json', ...__stxHeaders(options.headers) },\n body: typeof body === 'string' || __stxRawBody(body) ? body : JSON.stringify(body)\n };\n var response = await __stxFetch('useMutation', resolvedUrl, fetchOpts);\n if (!response.ok) throw await __stxHttpError(response);\n var result = await response.json();\n var transformed = options.transform ? options.transform(result) : result;\n data.set(transformed);\n if (options.onSuccess) options.onSuccess(transformed);\n // Invalidate related queries\n if (options.invalidateQueries) {\n options.invalidateQueries.forEach(function(key) { delete _queryCache[key]; });\n }\n return transformed;\n }\ncatch (e) {\n error.set(e.message || 'Mutation failed');\n // Rollback optimistic update\n if (options.optimisticData) data.set(previousData);\n if (options.onError) options.onError(e);\n throw e;\n }\nfinally {\n loading.set(false);\n }\n };\n\n return {\n data: data,\n loading: loading,\n error: error,\n mutate: mutate,\n reset: function() { data.set(null); error.set(null); loading.set(false); }\n };\n }\n";
2
+ export declare const SIGNALS_QUERY_RUNTIME: string;
@@ -1,2 +1,2 @@
1
1
  /** Vue-compatible reactive helpers used by the generated client runtime. */
2
- export declare const SIGNALS_REACTIVE_RUNTIME = " // Vue-compat aliases\n var ref = state;\n\n // reactive() used to be a bare alias of state(), which made it the most\n // dangerous name in the runtime. state({n:0}) returns a SIGNAL, so the Vue\n // shape everyone reaches for silently did nothing:\n //\n // const s = reactive({ count: 0 })\n // s.count // undefined \u2014 a signal has no such property\n // s.count++ // writes an expando onto a function object\n // {{ s.count }} // renders empty, forever, with no warning\n //\n // Backed by one signal PER PROPERTY, created on first touch. That is what\n // makes a read inside an effect track only the field it read, so writing\n // b does not re-run an effect that only read a (#1885).\n var __stxReactiveProxies = new WeakMap();\n\n function reactive(target) {\n // Primitives have no properties to track. Returning them unchanged keeps\n // reactive(0) from silently becoming an object.\n if (!target || typeof target !== 'object') return target;\n var existing = __stxReactiveProxies.get(target);\n if (existing) return existing;\n\n var propSignals = Object.create(null);\n function signalFor(prop) {\n if (!propSignals[prop]) propSignals[prop] = state(target[prop]);\n return propSignals[prop];\n }\n\n var proxy = new Proxy(target, {\n get: function(t, prop, receiver) {\n // Symbols and inherited members are plumbing \u2014 toJSON, Symbol.iterator,\n // array methods. Tracking them would create a signal per method lookup\n // and make every effect depend on the whole object.\n if (typeof prop === 'symbol' || !Object.prototype.hasOwnProperty.call(t, prop))\n return Reflect.get(t, prop, receiver);\n var value = signalFor(prop)();\n // Nested objects are wrapped too, and cached in the WeakMap, so\n // identity is stable across reads \u2014 a fresh proxy each time would\n // break === comparisons and defeat keyed list reuse.\n return (value && typeof value === 'object') ? reactive(value) : value;\n },\n set: function(t, prop, value) {\n if (typeof prop === 'symbol') return Reflect.set(t, prop, value);\n var had = Object.prototype.hasOwnProperty.call(t, prop);\n t[prop] = value;\n // Write the plain target FIRST so a signal created later reads the\n // current value, then notify anyone already watching this property.\n if (propSignals[prop]) propSignals[prop].set(value);\n else if (had) signalFor(prop);\n return true;\n },\n deleteProperty: function(t, prop) {\n var had = Object.prototype.hasOwnProperty.call(t, prop);\n delete t[prop];\n if (had && propSignals[prop]) propSignals[prop].set(undefined);\n return true;\n },\n });\n\n __stxReactiveProxies.set(target, proxy);\n return proxy;\n }\n var computed = derived;\n var watch = $watch;\n var watchEffect = function(fn) { return effect(fn); };";
2
+ export declare const SIGNALS_REACTIVE_RUNTIME: string;
@@ -1,2 +1,2 @@
1
1
  /** Template ref accessor used by page and component scopes. */
2
- export declare const SIGNALS_REF_RUNTIME = " // ==========================================================================\n // Template Refs (useRef)\n // ==========================================================================\n\n function useRef(name) {\n // A ref belongs to the component scope that created it. Capturing that\n // owner now is essential: componentScope is a mutable compatibility\n // fallback and changes while the rest of the page hydrates. Reading it\n // from the getter made an early component resolve refs from whichever\n // component happened to hydrate last.\n var ownerScope = currentLifecycleScope() || componentScope;\n var ownerRefs = ownerScope.$refs || (ownerScope.$refs = {});\n\n // Callable, as well as .current / .value.\n //\n // Every other accessor a script destructures alongside this one is\n // call-style \u2014 state(), derived(), useReactiveProp() \u2014 so myRef() is what\n // a reader reaches for, and it used to throw \"myRef is not a function\".\n // Inside effect()'s first run that throw escaped the effect, escaped the\n // generated setup function, and left the WHOLE page unhydrated: every\n // @click inert, every interpolation unbound, the markup otherwise\n // perfect. Either API alone looked fine, which is what made it hard to\n // see. Same reasoning as useCookie becoming a Signal in #1710.\n //\n // No backticks in here: this whole runtime is a template literal.\n var read = function () {\n return ownerRefs[name] || null;\n };\n Object.defineProperty(read, 'current', { get: read, enumerable: true });\n Object.defineProperty(read, 'value', { get: read, enumerable: true });\n return read;\n }\n";
2
+ export declare const SIGNALS_REF_RUNTIME: string;
@@ -1,2 +1,2 @@
1
1
  /** Scope and effect disposal used by the generated client runtime. */
2
- export declare const SIGNALS_SCOPE_DISPOSAL_RUNTIME = " // ==========================================================================\n // Scope Disposal\n // ==========================================================================\n\n // Walk a subtree (root + descendants) and fire each [data-stx-scope]'s\n // destroy callbacks + remove the entry from window.stx._scopes. Pre-fix\n // (stacksjs/stx#1727) only cleanupContainer (called during SPA navigation)\n // ran this walk, so dynamic unmounts driven by :if/:for leaked scopes\n // indefinitely. Now bindIf, bindFor, and cleanupContainer all funnel\n // through this helper so the cleanup is symmetric regardless of who\n // initiated the removal.\n // Dispose the EFFECTS bound inside a subtree leaving the page for good: a\n // removed :for row, a hidden template :if clone, a hidden :for empty\n // placeholder, or a container on SPA navigation (#1954).\n // disposeSubtreeScopes only releases scope registrations. Without this, the\n // effects that bound the subtree stay subscribed to every signal they read\n // and keep running, so work per update grows with every removal.\n // Descendants first, then the root, the order cleanupContainer always used.\n function disposeSubtreeEffects(root) {\n if (!root) return;\n var nodes = stxHost.descendants(root);\n nodes.push(root);\n var owned = ['__stx_disposers', '__stx_effect_disposers', '__stx_if_disposers', '__stx_chain_disposers'];\n for (var n = 0; n < nodes.length; n++) {\n var el = nodes[n];\n if (typeof el.__stx_hydration_cancel === 'function') {\n try { el.__stx_hydration_cancel(); } catch (e) { /* noop */ }\n el.__stx_hydration_cancel = null;\n }\n if (Array.isArray(el.__stx_destroy)) {\n var hooks = el.__stx_destroy;\n el.__stx_destroy = null;\n hooks.forEach(function(fn) {\n try { fn(); }\n catch (e) { console.warn('[stx] destroy hook error:', e); }\n });\n }\n if (el.__stx_detached_if) {\n var detached = el.__stx_detached_if;\n el.__stx_detached_if = null;\n detached.forEach(function(node) { disposeSubtreeEffects(node); });\n }\n for (var k = 0; k < owned.length; k++) {\n var disposeOwned = el[owned[k]];\n if (typeof disposeOwned === 'function') {\n el[owned[k]] = null;\n disposeOwned();\n }\n }\n }\n }\n\n // :if is a toggle, and a component inside one lives through every toggle:\n // its scope is registered once and kept (#1737), and showing the branch puts\n // the same markup back. Its LIFECYCLE follows the toggle, though. Hiding runs\n // what the component registered to release -- its onDestroy, and whatever\n // its onMount handed back -- and showing it again runs its onMount again.\n // Each show is a mount and each hide an unmount, which is the pairing every\n // component on a page already gets.\n //\n // Before this, a hidden component never heard about it and a re-shown one\n // was never told it was back (the asymmetry stacksjs/stx#2036 stopped short\n // of). A gated modal shell -- one that traps focus, locks body scroll and\n // claims Escape from onMount, and releases them in onDestroy -- did all of\n // that on its first opening and on no later one: the second time it opened\n // with the page scrolling behind it and Escape doing nothing.\n //\n // Only scopes that actually mounted are suspended, so a component whose\n // first mount is still deferred (behind a false :if, or an stx-hydrate\n // island) keeps waiting for its own flush.\n function suspendSubtreeScopes(nodes) {\n if (!nodes || !window.stx || !window.stx._scopes) return;\n var ids = [];\n for (var i = 0; i < nodes.length; i++) {\n var found = stxHost.scopesIn(nodes[i]);\n for (var k = 0; k < found.length; k++) {\n if (ids.indexOf(found[k]) === -1) ids.push(found[k]);\n }\n }\n // Innermost first, the order a page unmounts in: a child releases what it\n // holds before the component it sits in does.\n for (var n = ids.length - 1; n >= 0; n--) {\n var scopeVars = window.stx._scopes[ids[n]];\n if (!scopeVars || !scopeVars.__mounted) continue;\n scopeVars.__mounted = false;\n scopeVars.__suspended = true;\n var release = scopeVars.__destroyCallbacks || [];\n // What onDestroy registered at setup is owed again at the next hide;\n // a cleanup a mount handed back belonged to that mount alone.\n scopeVars.__destroyCallbacks = (scopeVars.__destroyHooks || []).slice();\n for (var j = 0; j < release.length; j++) {\n try { release[j](); }\n catch (e) { console.warn('[stx] scope destroy error:', e); }\n }\n scopeVars.__mountCallbacks = (scopeVars.__mountHooks || []).slice();\n }\n }\n\n // The other half: a suspended scope whose markup is back on the page mounts\n // again. A scope still off the page (hidden by an :if of its own inside this\n // branch) is left for that :if to resume.\n function resumeSubtreeScopes(nodes) {\n if (!nodes || !window.stx || !window.stx._scopes) return;\n for (var i = 0; i < nodes.length; i++) {\n var ids = stxHost.scopesIn(nodes[i]);\n for (var k = 0; k < ids.length; k++) {\n var scopeVars = window.stx._scopes[ids[k]];\n if (!scopeVars || scopeVars.__mounted || !scopeVars.__suspended) continue;\n if (scopeVars.__el && scopeVars.__el.isConnected === false) continue;\n scopeVars.__suspended = false;\n scopeVars.__mounted = true;\n runMountCallbacks(scopeVars.__mountCallbacks, scopeDestroySink(scopeVars));\n }\n }\n }\n\n function disposeSubtreeScopes(root) {\n if (!root || !window.stx || !window.stx._scopes) return;\n // The host reports which scopes live in this subtree: the document finds\n // them with a selector, a native host reads the map it keeps as it builds\n // views (#1984).\n var scopeIds = stxHost.scopesIn(root);\n for (var n = 0; n < scopeIds.length; n++) {\n var scopeId = scopeIds[n];\n if (!scopeId) continue;\n var scopeVars = window.stx._scopes[scopeId];\n if (!scopeVars) continue;\n // Hidden by an :if, it already released everything on the way out;\n // running the hooks again would unmount it twice. (A hidden component's\n // root is detached, so no walk reaches it today; this keeps the next\n // disposal path that does from unmounting it twice.)\n var alreadyReleased = scopeVars.__suspended && !scopeVars.__mounted;\n if (!alreadyReleased && scopeVars.__destroyCallbacks && Array.isArray(scopeVars.__destroyCallbacks)) {\n for (var j = 0; j < scopeVars.__destroyCallbacks.length; j++) {\n try { scopeVars.__destroyCallbacks[j](); }\n catch (e) { console.warn('[stx] scope destroy error:', e); }\n }\n }\n delete window.stx._scopes[scopeId];\n }\n }\n\n // Reclaim registry entries whose element is gone from the document.\n //\n // disposeSubtreeScopes only deletes scopes found UNDER the cleanup container,\n // so two shapes leaked forever across SPA navigation (#1775): components\n // rendered outside the swap container (an @include in the layout, above\n // <main>), and elements already detached by the time cleanup ran its\n // querySelectorAll. Each round-trip re-ran the include scripts under fresh\n // scope ids while the previous ids stayed in window.stx._scopes \u2014 ~4 orphans\n // per hop, unbounded, each retaining that scope's vars, signals and closures.\n // Since #1958 a same-layout navigation no longer re-runs the layout's\n // component scripts, and a layout change cleans up the whole body first, so\n // navigation should no longer produce the first shape; the sweep stays for\n // the second, and as the backstop for anything that still does.\n //\n // The sweep is deliberately CONSERVATIVE \u2014 an over-eager delete is the #1737\n // failure (a scope removed from the registry cannot be recreated: its setup\n // IIFE ran once at page load), which is strictly worse than a leak. An entry\n // is dropped only when all three hold:\n // 1. the runtime actually bound it to an element (__el recorded),\n // 2. that element is no longer connected to the document, and\n // 3. neither it nor any ancestor is retained by a live conditional.\n // Entries with no __el (e.g. a scope whose element still sits inside untouched\n // <template> content, never inserted) are left alone \u2014 we can't prove they're\n // dead, and a later clone re-uses that registration.\n function sweepOrphanedScopes() {\n if (!window.stx || !window.stx._scopes) return;\n var scopes = window.stx._scopes;\n for (var id in scopes) {\n if (!Object.prototype.hasOwnProperty.call(scopes, id)) continue;\n var entry = scopes[id];\n if (!entry) continue;\n var el = entry.__el;\n if (!el || el.isConnected) continue;\n // Detached but RETAINED: :if toggles keep their element (bindIf re-inserts\n // the SAME node) and :if/:else chains keep their branches. Parent links\n // inside a detached subtree stay intact, so walking up from the scope\n // element still finds the conditional that owns it.\n var retained = false;\n for (var p = el; p; p = p.parentNode) {\n if (p.__stx_if_bound || p.__stx_chain_member) { retained = true; break; }\n }\n if (retained) continue;\n // Suspended by an :if: released when it hid, so not again here.\n if (!(entry.__suspended && !entry.__mounted) && entry.__destroyCallbacks && Array.isArray(entry.__destroyCallbacks)) {\n for (var k = 0; k < entry.__destroyCallbacks.length; k++) {\n try { entry.__destroyCallbacks[k](); }\n catch (e) { console.warn('[stx] scope destroy error:', e); }\n }\n }\n delete scopes[id];\n }\n }\n";
2
+ export declare const SIGNALS_SCOPE_DISPOSAL_RUNTIME: string;
@@ -1,2 +1,2 @@
1
1
  /** Scoped-tree traversal used by the generated client runtime. */
2
- export declare const SIGNALS_SCOPE_TRAVERSAL_RUNTIME = " // Helper to process elements while skipping already-processed scoped containers\n function processElementSkipScopes(el, processedScopes) {\n if (processedScopes.has(el)) return;\n if (el.nodeType === Node.TEXT_NODE) {\n processElement(el);\n return;\n }\n if (el.nodeType !== Node.ELEMENT_NODE) return;\n // Skip scoped elements - they were already processed\n if (el.hasAttribute && el.hasAttribute('data-stx-scope')) return;\n // Inactive chain members are owned by bindIfChain. Use explicit branch\n // state because an active nested branch can live under a detached outer\n // conditional while its reactive effects continue to run.\n if (el.__stx_chain_member && !el.__stx_chain_active) return;\n // Process this element's directives without recursing into children\n // (we'll handle children manually to skip scoped ones)\n const hasFor = el.hasAttribute && (el.hasAttribute('@for') || el.hasAttribute(':for') || el.hasAttribute('x-for'));\n const hasIf = el.hasAttribute && (el.hasAttribute('@if') || el.hasAttribute(':if') || el.hasAttribute('x-if'));\n if (hasFor) { var fa = el.hasAttribute(':for') ? ':for' : el.hasAttribute('x-for') ? 'x-for' : '@for'; bindFor(el, componentScope, fa); return; }\n if (hasIf) {\n var ia = el.hasAttribute(':if') ? ':if' : el.hasAttribute('x-if') ? 'x-if' : '@if';\n var ic = findIfChain(el, ia);\n if (ic.length > 1) bindIfChain(ic, componentScope);\n else bindIf(el, componentScope, ia);\n return;\n }\n // Process other attributes...\n var isNativeModal = el.tagName === 'MODAL';\n if (el.hasAttribute && ((el.hasAttribute('@show') && !isNativeModal)\n || el.hasAttribute(':show') || el.hasAttribute('x-show'))) {\n var sa = el.hasAttribute(':show') ? ':show' : el.hasAttribute('x-show') ? 'x-show' : '@show';\n bindShow(el, el.getAttribute(sa), componentScope, sa);\n }\n var mb = getModelBinding(el);\n if (mb) {\n bindModel(el, mb.expression, componentScope, mb.name);\n }\n // Process children, skipping scoped containers and script/style elements\n if (el.tagName !== 'SCRIPT' && el.tagName !== 'STYLE') {\n Array.from(el.childNodes).forEach(child => processElementSkipScopes(child, processedScopes));\n }\n }";
2
+ export declare const SIGNALS_SCOPE_TRAVERSAL_RUNTIME: string;
@@ -1,2 +1,2 @@
1
1
  /** Reactive visibility binding for the generated client runtime. */
2
- export declare const SIGNALS_SHOW_RUNTIME = " function bindShow(el, expr, passedScope = componentScope, attrName = '@show') {\n if (el.__stx_show_bound) return;\n el.__stx_show_bound = true;\n\n const capturedScope = { ...globalHelpers, ...passedScope, ...(findElementScope(el) || {}) };\n\n // Check if the expression is a simple signal reference (most common case for :show)\n const directSignal = capturedScope[expr];\n if (directSignal && directSignal._isSignal) {\n // Fast path: directly subscribe to the signal \u2014 guaranteed reactive\n effect(() => {\n const value = directSignal();\n\n stxHost.setVisible(el, !!value);\n });\n } else {\n // Complex expression path \u2014 use createAutoUnwrapProxy with fallback,\n // matching the retry pattern in evalAttrExpr. This ensures call\n // expressions like !recording() work: the proxy auto-unwraps\n // signals on property access, so recording remains a callable\n // signal function (not unwrapped to its boolean value).\n effect(() => {\n var value;\n try {\n var unwrapScope = createExpressionAutoUnwrapProxy(capturedScope, expr);\n var fn = __stxCompileScoped(capturedScope, [], 'return ' + expr);\n value = fn(...__stxArgs(fn, unwrapScope));\n } catch (e1) {\n // Retry without unwrapping \u2014 handles edge cases where the proxy\n // interferes with certain expression patterns\n try {\n var fn2 = __stxCompileScoped(capturedScope, [], 'return ' + expr);\n value = fn2(...__stxArgs(fn2, capturedScope));\n } catch (e2) {\n // Suppress ReferenceError/TypeError during async init \u2014 a signal\n // or object may not be ready yet on the first effect run, and\n // the next pass will re-evaluate once data arrives.\n if (!(e2 instanceof ReferenceError) && !(e2 instanceof TypeError)) console.warn('[STX] Show expression error:', expr, e2);\n stxHost.setVisible(el, false);\n return;\n }\n }\n var wasVisible = stxHost.setVisible(el, !!value);\n // When transitioning from hidden to visible, stamp the element so\n // @click handlers can ignore clicks from the same frame (prevents\n // modal backdrop from catching the click that opened the modal)\n if (value && !wasVisible) {\n el.__stx_shown_at = performance.now();\n }\n });\n }\n el.removeAttribute(attrName);\n }\n";
2
+ export declare const SIGNALS_SHOW_RUNTIME: string;
@@ -1,2 +1,2 @@
1
1
  /** SPA load scheduling and teardown boundaries for the generated client runtime. */
2
- export declare const SIGNALS_SPA_LOAD_CONTROL_RUNTIME = " // Re-initialize components after SPA content swap.\n // Debounce to handle rapid re-fires (HMR triggers navigate which triggers stx:load again).\n var _stxLoadTimer = null;\n if (window.__stxLoadHandler) {\n window.removeEventListener('stx:load', window.__stxLoadHandler);\n }\n function stxLoadHandler() {\n if (_stxLoadTimer) { clearTimeout(_stxLoadTimer); }\n _stxLoadTimer = setTimeout(_handleStxLoad, 5);\n }\n window.__stxLoadHandler = stxLoadHandler;\n window.addEventListener('stx:load', stxLoadHandler);\n\n // Run a pending stx:load now instead of after the debounce. The router's\n // instant navigation (a tab bar) reveals the new screen in a single frame\n // once the page is bound; waiting out the timer revealed it with its\n // {{ }} still unbound and filled it in a frame later.\n function flushStxLoad() {\n if (!_stxLoadTimer) return false;\n clearTimeout(_stxLoadTimer);\n _handleStxLoad();\n return true;\n }\n // The page-level onDestroy callbacks a navigation is leaving behind.\n //\n // stx:load used to run everything in destroyCallbacks, on the reading that\n // the queue held the outgoing page. It does not by then: the router runs the\n // incoming page's scripts BEFORE it fires stx:load, and a page-level\n // onDestroy registered by one of them (a layout partial's useColorMode, a\n // listener, a stream) joined the same queue and was run at once - its owner\n // still on screen. A tab bar that retains screens made it certain, since\n // that path had already filed the outgoing page's callbacks with its screen,\n // so the queue stx:load drained held only the new page's. The page then\n // stopped following the system theme, among other things, until a reload.\n //\n // The router marks the boundary with _beginSwap just before the incoming\n // scripts run. Null means no boundary was marked since the last stx:load (a\n // re-fire, an older router), and then the queue is drained as before.\n var departingDestroys = null;\n function beginSwap() {\n departingDestroys = (departingDestroys || []).concat(destroyCallbacks.splice(0));\n }";
2
+ export declare const SIGNALS_SPA_LOAD_CONTROL_RUNTIME: string;
@@ -1,2 +1,2 @@
1
1
  /** SPA content rehydration used by the generated client runtime. */
2
- export declare const SIGNALS_SPA_LOAD_RUNTIME = " function _handleStxLoad() {\n _stxLoadTimer = null;\n console.log('[stx:load] START. mountQueue:', mountQueue.length, '_latestSetup:', !!window.stx._latestSetup);\n\n // Run the outgoing page's destroy callbacks before re-initializing. Taken\n // out of their queue first, so one that registers another lands in the\n // next generation instead of being cleared unrun.\n var departing = departingDestroys !== null ? departingDestroys : destroyCallbacks.splice(0);\n departingDestroys = null;\n departing.forEach(function(fn) {\n try { fn(); }\ncatch (e) { console.warn('[stx] destroy callback error:', e); }\n });\n\n // Re-process scoped components in new content\n var routerOpts = window.STX_ROUTER_OPTIONS || window.__stxRouterConfig || {};\n var container = document.querySelector('[data-stx-content]')\n || (routerOpts.container ? document.querySelector(routerOpts.container) : null)\n || document.querySelector('main')\n || document.querySelector('#main-content')\n || document.body;\n\n // Apply new page's SFC setup function. During SPA navigation, re-executed page\n // scripts set window.stx._latestSetup to the new setup function. This takes priority\n // over the stale data-stx attribute on body> (which has the PREVIOUS page's function name).\n var usedLatestSetup = false;\n if (window.stx._latestSetup && typeof window.stx._latestSetup === 'function') {\n try {\n var setupResult = window.stx._latestSetup();\n // Keep _latestSetup for re-fires (HMR, auto-refresh re-navigation)\n // It will be overwritten when a NEW page's script sets it\n usedLatestSetup = true;\n if (typeof setupResult === 'object' && setupResult !== null) {\n console.log('[stx:load] _latestSetup keys:', Object.keys(setupResult).slice(0, 10));\n Object.assign(componentScope, setupResult);\n }\n } catch (e) {\n console.error('[stx:load] _latestSetup error:', e);\n usedLatestSetup = true; // Don't fall back to stale data-stx\n }\n }\n console.log('[stx:load] usedLatestSetup:', usedLatestSetup, 'scope keys:', Object.keys(componentScope).slice(0, 10));\n\n // Only fall back to [data-stx] attribute lookup if _latestSetup wasn't available.\n // This handles the initial DOMContentLoaded-like case and pages that don't use _latestSetup.\n if (!usedLatestSetup) {\n document.querySelectorAll('[data-stx]').forEach(function(el) {\n var setupName = el.getAttribute('data-stx');\n if (setupName && window[setupName]) {\n var result = window[setupName]();\n if (typeof result === 'object') Object.assign(componentScope, result);\n }\n });\n }\n var spaPageScopeSnapshot = { ...componentScope };\n\n // Routed component mount scripts execute after DOMContentLoaded. Queue them\n // until the destination page setup is active so projected props and parent\n // event handlers resolve against the caller, matching initial hydration.\n mountQueue.forEach(function(fn) { fn(); });\n mountQueue = [];\n\n // Initialize x-data scopes after SPA fragment swap.\n // On full page load, the reactive bridge <script> calls initScope(). But after SPA\n // navigation, only the HTML fragment is swapped \u2014 the bridge script isn't re-executed.\n // The server renames x-data \u2192 data-stx-xdata so we can read the state expression here.\n if (window.__stx_reactive && window.__stx_reactive.initScope) {\n container.querySelectorAll('[data-stx-xdata]').forEach(function(el) {\n var scopeId = el.getAttribute('data-stx-scope');\n // Skip if scope already registered (e.g. nav scope that persists across navigations)\n if (scopeId && window.stx._scopes && window.stx._scopes[scopeId]) return;\n var xdata = el.getAttribute('data-stx-xdata');\n if (!xdata) return;\n // Assign a scope ID if not already present\n if (!scopeId) {\n scopeId = '__stx_scope_spa_' + (++window.stx._scopeCounter);\n el.setAttribute('data-stx-scope', scopeId);\n }\n // The init expression, which used to be dropped here. A scope\n // re-initialized with its data and none of its setup renders every\n // binding at its initial value and starts nothing - a live region\n // showing its empty state forever, which is indistinguishable from one\n // where nothing has happened yet.\n var xinit = el.getAttribute('data-stx-xinit');\n console.log('[stx:load] initializing x-data scope:', scopeId, xdata.substring(0, 40));\n window.__stx_reactive.initScope(el, xdata, [], {}, xinit || null);\n });\n }\n\n // Apply scope from [data-stx-scope] elements and process them.\n // Walk document.body (not just container) so layout-level scopes dropped\n // by a full-body-swap SPA nav (e.g. nav/header/footer when the layout\n // group changes) get bound. The __stx_disposers guard makes the walk\n // idempotent \u2014 persistent layout scopes across same-layout navs are\n // skipped instead of double-disposed. See stacksjs/stx#1697.\n document.body.querySelectorAll('[data-stx-scope]').forEach(function(el) {\n var scopeId = el.getAttribute('data-stx-scope');\n var scopeVars = window.stx._scopes && window.stx._scopes[scopeId];\n // Record the bound element for the orphan sweep (#1775) \u2014 see the\n // DOMContentLoaded walk above for the rationale.\n if (scopeVars) scopeVars.__el = el;\n // Deferred island reached via SPA navigation (#1746): its setup script is\n // inert (type=\"stx/island\"), so the scope isn't registered yet. Arm the\n // hydration trigger (deferHydration) instead of skipping it \u2014 mirrors the\n // initial-load DOMContentLoaded path, which has the same guard. Without\n // this, a client=\"visible|idle|\u2026\" island on a page reached by SPA nav\n // (inline OR chunked) never hydrates.\n if (!scopeVars && el.hasAttribute && el.hasAttribute('stx-hydrate')\n && !el.__stx_hydration_scheduled\n && document.querySelector('script[data-stx-island=\"' + scopeId + '\"]')) {\n processElement(el, componentScope);\n el.removeAttribute('x-cloak');\n el.querySelectorAll('[x-cloak]').forEach(function(c) { c.removeAttribute('x-cloak'); });\n return;\n }\n if (!scopeVars) return;\n el.__stx_parent_scope = el.__stx_parent_scope\n || resolveComponentCallerScope(el, spaPageScopeSnapshot);\n bindParentComponentProps(el, el.__stx_parent_scope);\n // Already bound: a layout component that stayed on the page. Its\n // bindings are live and read its own scope, so there is nothing to\n // merge \u2014 and merging it AFTER the destination page's setup let a name\n // the two share take the component's value for the page. The offline\n // banner's connected flag read as a Settings card's \"Connected\".\n if (el.__stx_disposers) return;\n Object.assign(componentScope, scopeVars);\n var disposeEffects = trackEffects(function() { processElement(el, componentScope); });\n el.__stx_disposers = disposeEffects;\n // A replacement layout's scope can live outside the router container.\n // Reveal it after binding, matching the initial hydration and mount paths.\n el.removeAttribute('x-cloak');\n el.querySelectorAll('[x-cloak]').forEach(function(c) { c.removeAttribute('x-cloak'); });\n });\n\n // The page's own names win over its components' locals. The walk above\n // merges each component's locals into the scope the container is bound\n // with, so a component declaring a name the page also declares took it\n // over for the whole page: HQ's coach dashboard aliases store signals as\n // loading and roster, a card further down declares its own loading and\n // roster, and reached by the router the page's\n // :if=\"loading && !roster.length\" read the card's and never cleared. A\n // full load binds the page before any component, so it never saw this.\n // A component's own bindings resolve its locals through its scope element,\n // and a name only a component declares stays reachable as before.\n Object.assign(componentScope, spaPageScopeSnapshot);\n\n // Process the container content \u2014 bind {{ }}, :attr, @event directives.\n // Run synchronously (not in setTimeout) so componentScope is captured correctly.\n // The DOMContentLoaded path processes body> synchronously \u2014 the SPA path must match.\n console.log('[stx:load] container:', container.tagName, '__stx_scope:', !!container.__stx_scope, 'scope keys:', Object.keys(componentScope).slice(0, 10));\n if (!container.__stx_scope) {\n // Dispose previous effects on the container (from prior navigation)\n if (container.__stx_disposers && typeof container.__stx_disposers === 'function') {\n container.__stx_disposers();\n }\n console.log('[stx:load] processElement on container');\n var disposeEffects = trackEffects(function() { processElement(container, componentScope); });\n container.__stx_disposers = disposeEffects;\n } else {\n console.log('[stx:load] SKIPPED processElement \u2014 container has __stx_scope');\n }\n\n // Remove x-cloak\n container.removeAttribute('x-cloak');\n container.querySelectorAll('[x-cloak]').forEach(function(c) { c.removeAttribute('x-cloak'); });\n\n // Fire mount callbacks from scoped components. Walk document.body so\n // layout-level scopes added by a full-body swap mount; __mounted guard\n // prevents persistent layout scopes from re-firing their onMount on\n // every same-layout SPA nav. See stacksjs/stx#1697.\n document.body.querySelectorAll('[data-stx-scope]').forEach(function(el) {\n var scopeId = el.getAttribute('data-stx-scope');\n var scopeVars = window.stx._scopes && window.stx._scopes[scopeId];\n if (scopeVars && scopeVars.__mountCallbacks && !scopeVars.__mounted) {\n scopeVars.__mounted = true;\n runMountCallbacks(scopeVars.__mountCallbacks, scopeDestroySink(scopeVars));\n }\n });\n\n // Flush global mountCallbacks (from scripts re-executed after SPA content swap)\n runMountCallbacks(mountCallbacks, destroyCallbacks);\n mountCallbacks.length = 0;\n\n // Everything that should have hydrated has now had its chance (#1773).\n auditHydration(container, 'stx:load');\n }\n";
2
+ export declare const SIGNALS_SPA_LOAD_RUNTIME: string;
@@ -1,2 +1,2 @@
1
1
  /** State and derived primitives embedded in the browser signals runtime. */
2
- export declare const SIGNALS_STATE_RUNTIME = " // ==========================================================================\n // State Signal\n // ==========================================================================\n\n function state(initialValue) {\n let value = initialValue;\n const subscribers = new Set();\n const effects = new Set();\n\n const signal = () => {\n if (activeEffect) {\n effects.add(activeEffect);\n }\n return value;\n };\n\n signal.set = (newValue) => {\n console.log('[stx] signal.set:', value, '->', newValue, 'effects:', effects.size);\n if (!Object.is(newValue, value)) {\n if (__stxDevtoolsTracking) {\n signal._setCount++;\n __stxDevtoolsStats.signalSets++;\n __stxDevtoolsMutations.push({ sid: signal._stxSignalId, prev: __stxShort(value), next: __stxShort(newValue) });\n if (__stxDevtoolsMutations.length > 100) __stxDevtoolsMutations.shift();\n }\n const prev = value;\n value = newValue;\n subscribers.forEach(cb => {\n try { cb(value, prev); }\n catch (e) { console.error('[stx] subscriber error:', e); }\n });\n notifySubscribers(effects);\n }\n };\n\n signal.update = (fn) => signal.set(fn(value));\n // Notify as if the value changed, for an array or object mutated in place.\n // set() cannot do it: the value is the same reference, so Object.is skips.\n signal.trigger = () => {\n subscribers.forEach(cb => {\n try { cb(value, value); }\n catch (e) { console.error('[stx] subscriber error:', e); }\n });\n notifySubscribers(effects);\n };\n signal.subscribe = (cb) => {\n subscribers.add(cb);\n return () => subscribers.delete(cb);\n };\n signal._isSignal = true;\n signal._effects = effects; // DevTools: the subscriber set (reactive graph)\n signal._setCount = 0; // DevTools: times set() changed the value (when tracking)\n signal._stxSignalId = ++__stxSignalId; // DevTools: stable id for the mutation log\n\n // Vue-compatible .value getter/setter for templates that use signal.value syntax\n Object.defineProperty(signal, 'value', {\n get() { return signal(); },\n set(v) { signal.set(v); },\n configurable: true\n });\n\n return signal;\n }\n\n // ==========================================================================\n // Derived Signal\n // ==========================================================================\n\n function derived(compute) {\n let cached;\n let isDirty = true;\n const effects = new Set();\n\n // Passes a change on to what read this value. A signal's notification\n // collects through it (_stxCollect) instead of calling it, so an effect\n // reached both directly and through here still runs once.\n const markDirty = () => {\n if (!isDirty) {\n isDirty = true;\n notifySubscribers(effects);\n }\n };\n markDirty._stxCollect = (into) => {\n if (!isDirty) {\n isDirty = true;\n collectSubscribers(effects, into);\n }\n };\n\n const signal = () => {\n if (activeEffect) effects.add(activeEffect);\n if (isDirty) {\n const prev = activeEffect;\n activeEffect = markDirty;\n effectStack.push(markDirty);\n try {\n cached = compute();\n }\nfinally {\n effectStack.pop();\n activeEffect = prev;\n }\n isDirty = false;\n }\n return cached;\n };\n\n signal._isDerived = true;\n signal._effects = effects; // DevTools: the subscriber set (reactive graph)\n\n // Vue-compatible .value getter for templates that use computed.value syntax\n Object.defineProperty(signal, 'value', {\n get() { return signal(); },\n configurable: true\n });\n\n return signal;\n }\n";
2
+ export declare const SIGNALS_STATE_RUNTIME: string;
@@ -1,2 +1,2 @@
1
1
  /** Browser storage composables used by the generated client runtime. */
2
- export declare const SIGNALS_STORAGE_RUNTIME = " // Storage access is guarded end to end (stacksjs/stx#1793). Every one of\n // these can throw, and each throw took down the whole client script for the\n // page rather than just the composable:\n //\n // getItem - SecurityError in a sandboxed iframe or with storage disabled\n // parse - any non-JSON value already sitting at the key\n // setItem - QuotaExceededError, Safari private mode\n //\n // The parse fallback is deliberately LENIENT: a value that isn't JSON is\n // returned as the raw string rather than discarded for defaultValue. A key\n // that previously held a bare 'list' keeps reading back 'list' and is\n // rewritten as JSON on the next set, so migrating an existing key onto this\n // composable no longer needs the key to be renamed. This also matches\n // composables/use-storage.ts, whose default serializer already returns the\n // raw string on parse failure \u2014 the two implementations have to agree.\n function stxParseStored(raw, fallback, key, label) {\n if (raw === null || raw === undefined) return fallback;\n try { return JSON.parse(raw); }\n catch (e) {\n console.warn('[stx] ' + label + ': \"' + key + '\" holds a value that is not JSON (' + String(raw).slice(0, 64) + '); using it as a raw string. Write it with the same composable to store it as JSON.');\n return raw;\n }\n }\n function stxStorageRead(store, key, fallback, label) {\n var raw;\n try { raw = store.getItem(key); }\n catch (e) {\n console.warn('[stx] ' + label + ': cannot read \"' + key + '\" (' + (e && e.message ? e.message : e) + '); using the default.');\n return fallback;\n }\n return stxParseStored(raw, fallback, key, label);\n }\n function stxStorageWrite(store, key, value, label) {\n try { store.setItem(key, JSON.stringify(value)); }\n catch (e) {\n console.warn('[stx] ' + label + ': cannot persist \"' + key + '\" (' + (e && e.message ? e.message : e) + '); the value stays in memory only.');\n }\n }\n\n function useLocalStorage(key, defaultValue) {\n var s = state(stxStorageRead(localStorage, key, defaultValue, 'useLocalStorage'));\n effect(function() {\n stxStorageWrite(localStorage, key, s(), 'useLocalStorage');\n });\n var handler = function(e) {\n // Fires from ANOTHER tab at an arbitrary later time, so an unguarded\n // parse here throws inside a window listener with a stack pointing at\n // the runtime rather than at the consumer.\n // storageArea is also matched so a sessionStorage write to the same key\n // name can't clobber this signal \u2014 useSessionStorage already filtered,\n // this side didn't. Synthetic events (tests) leave storageArea null and\n // are still accepted; real browsers always populate it.\n if (e.key === key && (!e.storageArea || e.storageArea === localStorage))\n s.set(stxParseStored(e.newValue, defaultValue, key, 'useLocalStorage'));\n };\n window.addEventListener('storage', handler);\n onDestroy(function() { window.removeEventListener('storage', handler); });\n return s;\n }\n\n // Mirror of useLocalStorage against sessionStorage. Strict-mode lint\n // already suggests this function name as the replacement for raw\n // window.sessionStorage access; this is the implementation that backs\n // that hint. Same JSON serialization, cross-tab sync via the 'storage'\n // event (filtered to sessionStorage's storageArea \u2014 localStorage events\n // share the same listener but fire from a different area).\n function useSessionStorage(key, defaultValue) {\n var s = state(stxStorageRead(sessionStorage, key, defaultValue, 'useSessionStorage'));\n effect(function() {\n stxStorageWrite(sessionStorage, key, s(), 'useSessionStorage');\n });\n var handler = function(e) {\n if (e.key === key && (!e.storageArea || e.storageArea === sessionStorage))\n s.set(stxParseStored(e.newValue, defaultValue, key, 'useSessionStorage'));\n };\n window.addEventListener('storage', handler);\n onDestroy(function() { window.removeEventListener('storage', handler); });\n return s;\n }";
2
+ export declare const SIGNALS_STORAGE_RUNTIME: string;