sigmx 0.1.1 → 0.2.0

package/README.md

@@ -8,11 +8,11 @@
 
 Your server renders HTML, as it always has. The browser asks for more of it with `@get` and `@post`, and sigmx merges the response into the page with a morph that keeps focus, typed input and scroll position. When you want live updates, the same request can return a stream of patches instead. Signals, two-way binding and reactive attributes cover the client-side state. You write `data-*` attributes and register only the plugins you use.
 
-- **Tiny.** 4.1 KB core, 8.8 KB with the essentials, 12.1 KB with all 52 plugins (brotli). Zero runtime dependencies.
+- **Tiny.** 4.5 KB core, 9.0 KB with the essentials, 11.5 KB with all 50 plugins (brotli). Zero runtime dependencies.
 - **Server-driven.** Return plain HTML from any endpoint and it is morphed into the page by id, or targeted with a header. Return JSON to merge signals, or an event stream to push many patches over one request, with `Last-Event-ID` reconnects.
 - **Reactive where it matters.** Signals declared in markup; `bind`, `show`, `class`, computed values and effects keep the page in step. No component model, no virtual DOM.
 - **Pay for what you use.** Every directive and function is an opt-in plugin, and auto mode scans your source to bundle exactly the set it finds.
-- **Batteries from the ecosystem.** The Alpine plugins (`collapse`, `mask`, `trap`, `teleport`, …) and htmx extensions (`boost`, `ws`, `remove-me`, …) people bolt on are built in as plugins.
+- **Batteries from the ecosystem.** The Alpine plugins (`collapse`, `mask`, `teleport`, …) and htmx extensions (`boost`, `ws`, `remove-me`, …) people bolt on are built in as plugins.
 - **Datastar-compatible markup.** Existing Datastar templates run unchanged.
 
 ```html
@@ -53,7 +53,7 @@ Attributes are `data-<plugin>[:key][__modifier.arg]="expression"`. Expressions a
 <button data-on:click__debounce.300ms="@get('/search')">Search</button>
 <li data-class:active="$page === 3"></li>
 <input data-bind:user.email />
-<p data-text="`${$items.length} items, ${@intl('number', $total, { style: 'currency', currency: 'EUR' })}`"></p>
+<p data-text="`${$items.length} items, ${@intl('NumberFormat', $total, { style: 'currency', currency: 'EUR' })}`"></p>
 ```
 
 State is one JSON-like store addressed by dotted paths and patched with merge-patch semantics: objects merge, `null` removes, arrays notify on `push`. Requests send the store (minus `_`-prefixed paths) and apply whatever comes back, decided by the response's content type:
@@ -81,10 +81,10 @@ data: elements <li>Validating…</li>
 | kind      | plugins                                                                                                        |
 | --------- | -------------------------------------------------------------------------------------------------------------- |
 | state     | `signals` `computed` `effect` `ref` `persist` `query-string`                                                   |
-| rendering | `text` `html` `show` `class` `style` `attr` `animate` `transition` `collapse` `view-transition` `cloak`        |
+| rendering | `text` `html` `show` `class` `style` `attr` `animate` `transition` `collapse` `cloak`                          |
 | forms     | `bind` `custom-validity` `mask`                                                                                |
 | events    | `on` `init` `on-interval` `on-intersect` `on-resize` `on-raf` `on-signal-patch` `match-media`                  |
-| layout    | `teleport` `trap` `scroll-into-view` `remove-me`                                                               |
+| layout    | `teleport` `scroll-into-view` `remove-me`                                                                      |
 | server    | `@get` `@post` `@put` `@patch` `@delete` `@ws` `boost` `indicator` `patch-elements` `patch-signals`            |
 | utilities | `@peek` `@setAll` `@toggleAll` `@fit` `@clipboard` `@intl` `@dispatch` `@confirm` `json-signals` `replace-url` |
 
@@ -96,14 +96,14 @@ Brotli, measured from the real source by `npm run size` and `npm run compare` (n
 
 |                                                             |  brotli |
 | ----------------------------------------------------------- | ------: |
-| sigmx core                                                  |  4.1 KB |
-| sigmx essentials (state, rendering, forms, requests, morph) |  8.8 KB |
-| sigmx everything, 52 plugins                                | 12.1 KB |
+| sigmx core                                                  |  4.5 KB |
+| sigmx essentials (state, rendering, forms, requests, morph) |  9.0 KB |
+| sigmx everything, 50 plugins                                | 11.5 KB |
 | htmx 2.0.10                                                 | 14.6 KB |
-| Datastar 1.0.3, free bundle (23 plugins)                    | 11.8 KB |
+| Datastar 1.0.3 (23 plugins)                                 | 11.8 KB |
 | Alpine.js 3.17.1                                            | 17.6 KB |
 
-Precompiling expressions at build time removes the runtime compiler and any use of `new Function`, taking the core to 3.7 KB and making strict CSP trivial.
+Precompiling expressions at build time removes the runtime compiler and any use of `new Function`, taking the core to 3.8 KB and making strict CSP trivial.
 
 ## Auto mode
 

package/dist/kernel/compile.d.ts

@@ -2,15 +2,14 @@ import type { ExpressionCompiler } from './contracts.js';
 export type Compiler = (params: string[], body: string) => (...args: any[]) => any;
 /** Default compiler: `new Function`. Not usable under a strict CSP; see `cspCompiler`. */
 export declare const functionCompiler: Compiler;
-/** Replace `@name(` with `__a.name(` outside strings and comments. */
-export declare const rewriteActions: (src: string) => string;
-/** Split on top-level semicolons. */
-export declare const splitStatements: (src: string) => string[];
+/** `$count + @fit($x)` → `$.count + __a.fit($.x)`; strings, template text, comments and regexes untouched. */
+export declare const transform: (src: string) => string;
 /**
- * Compile an expression to `(store, actions, ...params) => any`: the body runs inside
- * `with (store.scope)`, so `$name` resolves through the store. With `returns`, the value of the
- * last statement is returned, so `$a = 1; $a * 2` works. Compiled functions are cached by source.
+ * Compile `src` with `compiler` as `($, __a, ...params) => any`, returning the body that compiled
+ * together with the function. Shared by the runtime and the build-time precompiler.
  */
-export declare const compile: (compiler: Compiler, src: string, params: string[], returns: boolean) => ((...args: any[]) => any);
-/** The default pipeline: compile at runtime inside `with (scope)` using `compiler` (`new Function` or CSP). */
+export declare const compileBody: (compiler: Compiler, src: string, params: string[]) => [string, (...args: any[]) => any];
+/** Compile with a cache keyed by parameter names and source. */
+export declare const compile: (compiler: Compiler, src: string, params: string[]) => ((...args: any[]) => any);
+/** The default pipeline: compile at runtime with `compiler` (`new Function` or the CSP compiler). */
 export declare const runtimeExpressions: (compiler: Compiler) => ExpressionCompiler;

package/dist/kernel/compile.js

@@ -1,96 +1,131 @@
 const functionCompiler = (params, body) => Function(...params, body);
-const cache = /* @__PURE__ */ new Map();
-const isIdent = (c) => /[A-Za-z0-9_$]/.test(c);
-const scan = (src, onCode) => {
-  let i = 0;
+const START = /[A-Za-z_$]/;
+const IDENT = /[\w$]/;
+const BEFORE_REGEX = /(^|[(,=:[!&|?{};+\-*%<>~^]|\b(?:return|typeof|case|in|of|do|else|void|delete|throw|new))$/;
+const rewrite = (src, from, hole) => {
+  let out = "";
+  let i = from;
+  let depth = 0;
   const n = src.length;
+  const code = () => out.trimEnd();
   while (i < n) {
     const c = src[i];
-    const next = src[i + 1];
-    if (c === '"' || c === "'" || c === "`") {
+    const d = src[i + 1];
+    if (c === '"' || c === "'") {
       let j = i + 1;
       while (j < n && src[j] !== c) j += src[j] === "\\" ? 2 : 1;
-      onCode(src.slice(i, j + 1), i);
+      out += src.slice(i, j + 1);
       i = j + 1;
-    } else if (c === "/" && next === "/") {
+    } else if (c === "`") {
+      out += c;
+      i++;
+      while (i < n && src[i] !== "`") {
+        if (src[i] === "\\") {
+          out += src.slice(i, i + 2);
+          i += 2;
+        } else if (src[i] === "$" && src[i + 1] === "{") {
+          const [inner, j] = rewrite(src, i + 2, true);
+          out += `\${${inner}}`;
+          i = j;
+        } else out += src[i++];
+      }
+      out += "`";
+      i++;
+    } else if (c === "/" && d === "/") {
       const j = src.indexOf("\n", i);
       i = j < 0 ? n : j;
-    } else if (c === "/" && next === "*") {
+    } else if (c === "/" && d === "*") {
       const j = src.indexOf("*/", i + 2);
       i = j < 0 ? n : j + 2;
-    } else {
-      const skip = onCode(c, i);
-      i += skip || 1;
-    }
-  }
-};
-const rewriteActions = (src) => {
-  let out = "";
-  scan(src, (c, i) => {
-    if (c === "@") {
+    } else if (c === "/" && BEFORE_REGEX.test(code())) {
+      let j = i + 1;
+      let cls = false;
+      for (; j < n && (cls || src[j] !== "/"); j++) {
+        if (src[j] === "\\") j++;
+        else if (src[j] === "[") cls = true;
+        else if (src[j] === "]") cls = false;
+      }
+      for (j++; j < n && /[a-z]/i.test(src[j]); j++) ;
+      out += src.slice(i, j);
+      i = j;
+    } else if (hole && (c === "{" || c === "}")) {
+      if (c === "{") depth++;
+      else if (depth) depth--;
+      else return [out, i + 1];
+      out += c;
+      i++;
+    } else if (c === "$" && START.test(d ?? "") && d !== "$" && !IDENT.test(out.at(-1) ?? "")) {
+      const before = code();
+      if (before.endsWith(".") && !before.endsWith("...")) {
+        out += c;
+        i++;
+        continue;
+      }
+      let j = i + 1;
+      while (j < n && IDENT.test(src[j])) j++;
+      out += `$.${src.slice(i + 1, j)}`;
+      i = j;
+    } else if (c === "@" && START.test(d ?? "")) {
       let j = i + 1;
-      while (j < src.length && isIdent(src[j])) j++;
+      while (j < n && IDENT.test(src[j])) j++;
       let k = j;
-      while (k < src.length && /\s/.test(src[k])) k++;
-      if (j > i + 1 && src[k] === "(") {
+      while (k < n && /\s/.test(src[k])) k++;
+      if (src[k] === "(") {
         out += `__a.${src.slice(i + 1, j)}(`;
-        return k + 1 - i;
+        i = k + 1;
+      } else {
+        out += c;
+        i++;
       }
+    } else {
+      out += c;
+      i++;
     }
-    out += c;
-  });
-  return out;
+  }
+  return [out, i];
 };
-const splitStatements = (src) => {
-  const parts = [];
-  let depth = 0;
-  let start = 0;
-  scan(src, (c, i) => {
-    if (c.length > 1) return;
-    if ("([{".includes(c)) depth++;
-    else if (")]}".includes(c)) depth--;
-    else if (c === ";" && !depth) {
-      parts.push(src.slice(start, i));
-      start = i + 1;
-    }
-  });
-  parts.push(src.slice(start));
-  return parts.filter((p) => p.trim());
+const transform = (src) => rewrite(src, 0, false)[0];
+const candidates = (code) => {
+  const out = [`return(${code}
+)`];
+  for (let i = code.lastIndexOf(";"); i >= 0; i = code.lastIndexOf(";", i - 1))
+    out.push(`${code.slice(0, i)};return(${code.slice(i + 1)}
+)`);
+  out.push(code);
+  return out.map((b) => `"use strict";${b}`);
 };
-const compile = (compiler, src, params, returns) => {
-  const key = `${+returns}|${params.join()}|${src}`;
-  const hit = cache.get(key);
-  if (hit) return hit;
-  const code = rewriteActions(src.trim());
-  const make = (body) => compiler(["$", "__a", ...params], `with($.scope){${body}
-}`);
-  let fn;
-  if (!returns) {
-    fn = make(code);
-  } else {
+const compileBody = (compiler, src, params) => {
+  let error;
+  for (const body of candidates(transform(src.trim()))) {
     try {
-      fn = make(`return(${code}
-)`);
-    } catch {
-      const parts = splitStatements(code);
-      const last = parts.pop() ?? "";
-      try {
-        fn = make(`${parts.join(";")};return(${last}
-)`);
-      } catch {
-        fn = make(code);
-      }
+      return [body, compiler(["$", "__a", ...params], body)];
+    } catch (e) {
+      error = e;
     }
   }
-  cache.set(key, fn);
+  throw error;
+};
+const cache = /* @__PURE__ */ new Map();
+const CACHE_LIMIT = 2e3;
+const compile = (compiler, src, params) => {
+  const key = `${params.join()}|${src}`;
+  let fn = cache.get(key);
+  if (!fn) {
+    fn = compileBody(compiler, src, params)[1];
+    if (cache.size >= CACHE_LIMIT) cache.delete(cache.keys().next().value);
+    cache.set(key, fn);
+  }
   return fn;
 };
-const runtimeExpressions = (compiler) => (src, params, returns) => compile(compiler, src, params, returns);
+const runtimeExpressions = (compiler) => (src, params) => {
+  const fn = compile(compiler, src, params);
+  return (store, actions, ...rest) => fn(store.$, actions, ...rest);
+};
 export {
   compile,
+  compileBody,
   functionCompiler,
-  rewriteActions,
   runtimeExpressions,
-  splitStatements
+  transform
 };
 //# sourceMappingURL=compile.js.map

package/dist/kernel/compile.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/kernel/compile.ts"],
-  "sourcesContent": ["// Expression compiler. Signals need no rewriting: the body runs inside `with (scope)`, where\n// `$count`, `$user.name` and `$` resolve through the store's scope proxy. Only `@action(` is\n// rewritten, into a call on the per-evaluation actions object.\n\nimport type { ExpressionCompiler } from './contracts.js';\n\nexport type Compiler = (params: string[], body: string) => (...args: any[]) => any;\n\n/** Default compiler: `new Function`. Not usable under a strict CSP; see `cspCompiler`. */\nexport const functionCompiler: Compiler = (params, body) => Function(...params, body) as (...args: any[]) => any;\n\nconst cache = new Map<string, (...args: any[]) => any>();\n\nconst isIdent = (c: string): boolean => /[A-Za-z0-9_$]/.test(c);\n\n/** Walk source text, skipping string, template and comment contents; `emit` receives code chars. */\n// biome-ignore lint/suspicious/noConfusingVoidType: callers may return nothing to keep scanning\nconst scan = (src: string, onCode: (c: string, i: number) => number | void): void => {\n  let i = 0;\n  const n = src.length;\n  while (i < n) {\n    const c = src[i];\n    const next = src[i + 1];\n    if (c === '\"' || c === \"'\" || c === '`') {\n      let j = i + 1;\n      while (j < n && src[j] !== c) j += src[j] === '\\\\' ? 2 : 1;\n      onCode(src.slice(i, j + 1), i);\n      i = j + 1;\n    } else if (c === '/' && next === '/') {\n      const j = src.indexOf('\\n', i);\n      i = j < 0 ? n : j;\n    } else if (c === '/' && next === '*') {\n      const j = src.indexOf('*/', i + 2);\n      i = j < 0 ? n : j + 2;\n    } else {\n      const skip = onCode(c, i);\n      i += skip || 1;\n    }\n  }\n};\n\n/** Replace `@name(` with `__a.name(` outside strings and comments. */\nexport const rewriteActions = (src: string): string => {\n  let out = '';\n  scan(src, (c, i) => {\n    if (c === '@') {\n      let j = i + 1;\n      while (j < src.length && isIdent(src[j])) j++;\n      let k = j;\n      while (k < src.length && /\\s/.test(src[k])) k++;\n      if (j > i + 1 && src[k] === '(') {\n        out += `__a.${src.slice(i + 1, j)}(`;\n        return k + 1 - i;\n      }\n    }\n    out += c;\n  });\n  return out;\n};\n\n/** Split on top-level semicolons. */\nexport const splitStatements = (src: string): string[] => {\n  const parts: string[] = [];\n  let depth = 0;\n  let start = 0;\n  scan(src, (c, i) => {\n    if (c.length > 1) return;\n    if ('([{'.includes(c)) depth++;\n    else if (')]}'.includes(c)) depth--;\n    else if (c === ';' && !depth) {\n      parts.push(src.slice(start, i));\n      start = i + 1;\n    }\n  });\n  parts.push(src.slice(start));\n  return parts.filter((p) => p.trim());\n};\n\n/**\n * Compile an expression to `(store, actions, ...params) => any`: the body runs inside\n * `with (store.scope)`, so `$name` resolves through the store. With `returns`, the value of the\n * last statement is returned, so `$a = 1; $a * 2` works. Compiled functions are cached by source.\n */\nexport const compile = (\n  compiler: Compiler,\n  src: string,\n  params: string[],\n  returns: boolean,\n): ((...args: any[]) => any) => {\n  const key = `${+returns}|${params.join()}|${src}`;\n  const hit = cache.get(key);\n  if (hit) return hit;\n  const code = rewriteActions(src.trim());\n  const make = (body: string) => compiler(['$', '__a', ...params], `with($.scope){${body}\\n}`);\n  let fn: (...args: any[]) => any;\n  if (!returns) {\n    fn = make(code);\n  } else {\n    try {\n      fn = make(`return(${code}\\n)`);\n    } catch {\n      const parts = splitStatements(code);\n      const last = parts.pop() ?? '';\n      try {\n        fn = make(`${parts.join(';')};return(${last}\\n)`);\n      } catch {\n        fn = make(code);\n      }\n    }\n  }\n  cache.set(key, fn);\n  return fn;\n};\n\n/** The default pipeline: compile at runtime inside `with (scope)` using `compiler` (`new Function` or CSP). */\nexport const runtimeExpressions =\n  (compiler: Compiler): ExpressionCompiler =>\n  (src, params, returns) =>\n    compile(compiler, src, params, returns);\n"],
-  "mappings": "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",
+  "sourcesContent": ["// Expression compiler. An attribute expression is rewritten once, `$name` \u2192 `$.name` and\n// `@name(` \u2192 `__a.name(`, then compiled as a strict-mode function of `($, __a, el, evt, ...args)`\n// where `$` is the store's root proxy. The build-time precompiler emits exactly the same bodies,\n// so precompiled and runtime expressions behave identically.\n\nimport type { ExpressionCompiler } from './contracts.js';\n\nexport type Compiler = (params: string[], body: string) => (...args: any[]) => any;\n\n/** Default compiler: `new Function`. Not usable under a strict CSP; see `cspCompiler`. */\nexport const functionCompiler: Compiler = (params, body) => Function(...params, body) as (...args: any[]) => any;\n\nconst START = /[A-Za-z_$]/;\nconst IDENT = /[\\w$]/;\n/** After these a `/` starts a regular expression rather than a division. */\nconst BEFORE_REGEX = /(^|[(,=:[!&|?{};+\\-*%<>~^]|\\b(?:return|typeof|case|in|of|do|else|void|delete|throw|new))$/;\n\n/**\n * Tokenizer-based rewrite. Copies string literals, template text, and regular expressions verbatim,\n * drops comments, recurses into `${\u2026}` holes, and rewrites signals and actions in code. In hole\n * mode it stops at the unmatched `}` and reports the index after it.\n */\nconst rewrite = (src: string, from: number, hole: boolean): [string, number] => {\n  let out = '';\n  let i = from;\n  let depth = 0;\n  const n = src.length;\n  const code = () => out.trimEnd();\n  while (i < n) {\n    const c = src[i];\n    const d = src[i + 1];\n    if (c === '\"' || c === \"'\") {\n      let j = i + 1;\n      while (j < n && src[j] !== c) j += src[j] === '\\\\' ? 2 : 1;\n      out += src.slice(i, j + 1);\n      i = j + 1;\n    } else if (c === '`') {\n      out += c;\n      i++;\n      while (i < n && src[i] !== '`') {\n        if (src[i] === '\\\\') {\n          out += src.slice(i, i + 2);\n          i += 2;\n        } else if (src[i] === '$' && src[i + 1] === '{') {\n          const [inner, j] = rewrite(src, i + 2, true);\n          out += `\\${${inner}}`;\n          i = j;\n        } else out += src[i++];\n      }\n      out += '`';\n      i++;\n    } else if (c === '/' && d === '/') {\n      const j = src.indexOf('\\n', i);\n      i = j < 0 ? n : j;\n    } else if (c === '/' && d === '*') {\n      const j = src.indexOf('*/', i + 2);\n      i = j < 0 ? n : j + 2;\n    } else if (c === '/' && BEFORE_REGEX.test(code())) {\n      let j = i + 1;\n      let cls = false;\n      for (; j < n && (cls || src[j] !== '/'); j++) {\n        if (src[j] === '\\\\') j++;\n        else if (src[j] === '[') cls = true;\n        else if (src[j] === ']') cls = false;\n      }\n      for (j++; j < n && /[a-z]/i.test(src[j]); j++);\n      out += src.slice(i, j);\n      i = j;\n    } else if (hole && (c === '{' || c === '}')) {\n      if (c === '{') depth++;\n      else if (depth) depth--;\n      else return [out, i + 1];\n      out += c;\n      i++;\n    } else if (c === '$' && START.test(d ?? '') && d !== '$' && !IDENT.test(out.at(-1) ?? '')) {\n      const before = code();\n      // `obj.$x` is a member access and stays; `...$x` is a spread and is a signal.\n      if (before.endsWith('.') && !before.endsWith('...')) {\n        out += c;\n        i++;\n        continue;\n      }\n      let j = i + 1;\n      while (j < n && IDENT.test(src[j])) j++;\n      out += `$.${src.slice(i + 1, j)}`;\n      i = j;\n    } else if (c === '@' && START.test(d ?? '')) {\n      let j = i + 1;\n      while (j < n && IDENT.test(src[j])) j++;\n      let k = j;\n      while (k < n && /\\s/.test(src[k])) k++;\n      if (src[k] === '(') {\n        out += `__a.${src.slice(i + 1, j)}(`;\n        i = k + 1;\n      } else {\n        out += c;\n        i++;\n      }\n    } else {\n      out += c;\n      i++;\n    }\n  }\n  return [out, i];\n};\n\n/** `$count + @fit($x)` \u2192 `$.count + __a.fit($.x)`; strings, template text, comments and regexes untouched. */\nexport const transform = (src: string): string => rewrite(src, 0, false)[0];\n\n/**\n * The strict-mode bodies to try, best first: the whole source as an expression, then each split at a\n * top-level-looking `;` from the end (statements followed by a returned value), then plain statements.\n * A split inside a string or bracket does not compile and the next candidate is tried.\n */\nconst candidates = (code: string): string[] => {\n  const out = [`return(${code}\\n)`];\n  for (let i = code.lastIndexOf(';'); i >= 0; i = code.lastIndexOf(';', i - 1))\n    out.push(`${code.slice(0, i)};return(${code.slice(i + 1)}\\n)`);\n  out.push(code);\n  return out.map((b) => `\"use strict\";${b}`);\n};\n\n/**\n * Compile `src` with `compiler` as `($, __a, ...params) => any`, returning the body that compiled\n * together with the function. Shared by the runtime and the build-time precompiler.\n */\nexport const compileBody = (compiler: Compiler, src: string, params: string[]): [string, (...args: any[]) => any] => {\n  let error: unknown;\n  for (const body of candidates(transform(src.trim()))) {\n    try {\n      return [body, compiler(['$', '__a', ...params], body)];\n    } catch (e) {\n      error = e;\n    }\n  }\n  throw error;\n};\n\nconst cache = new Map<string, (...args: any[]) => any>();\nconst CACHE_LIMIT = 2000; // a long-lived page streaming unique expressions must not grow without bound\n\n/** Compile with a cache keyed by parameter names and source. */\nexport const compile = (compiler: Compiler, src: string, params: string[]): ((...args: any[]) => any) => {\n  const key = `${params.join()}|${src}`;\n  let fn = cache.get(key);\n  if (!fn) {\n    fn = compileBody(compiler, src, params)[1];\n    if (cache.size >= CACHE_LIMIT) cache.delete(cache.keys().next().value as string);\n    cache.set(key, fn);\n  }\n  return fn;\n};\n\n/** The default pipeline: compile at runtime with `compiler` (`new Function` or the CSP compiler). */\nexport const runtimeExpressions =\n  (compiler: Compiler): ExpressionCompiler =>\n  (src, params) => {\n    const fn = compile(compiler, src, params);\n    return (store, actions, ...rest) => fn(store.$, actions, ...rest);\n  };\n"],
+  "mappings": "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",
   "names": []
 }

package/dist/kernel/contracts.d.ts

@@ -6,7 +6,7 @@ export type Mods = Map<string, string[]>;
 /** A compiled attribute expression. `store` is the instance store; `actions` resolves `@name(...)`. */
 export type Evaluator = (store: Store, actions: any, el: El, evt: Event | undefined, ...args: any[]) => any;
 /** Turns expression source into an evaluator. The runtime compiler and the precompiled table both implement this. */
-export type ExpressionCompiler = (src: string, params: string[], returns: boolean) => Evaluator;
+export type ExpressionCompiler = (src: string, params: string[]) => Evaluator;
 export interface Runtime {
     /** Attribute prefixes being scanned; the first is primary. */
     readonly prefixes: readonly string[];
@@ -42,8 +42,11 @@ export interface Ctx {
     effect(fn: () => void): void;
     /** addEventListener with automatic removal on cleanup. */
     listen(target: EventTarget, type: string, fn: (e: any) => void, options?: AddEventListenerOptions): void;
-    cleanup(fn: () => void): void;
+    /** Run `fn` when the attribute unmounts. Returns a function that unregisters it (for work that finished early). */
+    cleanup(fn: () => void): () => void;
     error(message: string, extra?: Record<string, unknown>): Error;
+    /** Route an error that happened later (a callback, a promise) to `onError` with this attribute's info. */
+    report(error: unknown): void;
     store: Store;
     runtime: Runtime;
 }
@@ -53,8 +56,10 @@ export interface ActionCtx {
     store: Store;
     runtime: Runtime;
     error(message: string, extra?: Record<string, unknown>): Error;
-    /** Run when the attribute that invoked the action is torn down. */
-    cleanup(fn: () => void): void;
+    /** Route an error that happened later (a callback, a promise) to `onError` with this attribute's info. */
+    report(error: unknown): void;
+    /** Run when the attribute that invoked the action is torn down. Returns a function that unregisters it. */
+    cleanup(fn: () => void): () => void;
 }
 export interface AttributePlugin {
     type: 'attribute';
@@ -62,7 +67,8 @@ export interface AttributePlugin {
     key?: 'required' | 'forbidden';
     value?: 'required' | 'forbidden';
     /** Whether the expression yields a value (default) or is a statement body. */
-    returns?: boolean;
+    /** The value is a literal (a mask, a selector, a delay) rather than an expression; `__dynamic` makes it one. */
+    literal?: boolean;
     /** Extra parameter names the expression can reference, in the order passed to `evaluate`. */
     args?: string[];
     mount(ctx: Ctx): void | (() => void);

package/dist/kernel/index.d.ts

@@ -1,9 +1,9 @@
 export { camel, kebab, pascal, recase, snake } from '../lib/casing.js';
 export type { Filter } from '../lib/objects.js';
 export { expand, isPlain, toPredicate } from '../lib/objects.js';
-export { debounce, delay, throttle, toMs, withTiming, withViewTransition } from '../lib/schedule.js';
+export { debounce, delay, throttle, toMs, withTiming } from '../lib/schedule.js';
 export type { Compiler } from './compile.js';
-export { compile, functionCompiler, rewriteActions, runtimeExpressions, splitStatements } from './compile.js';
+export { compile, compileBody, functionCompiler, runtimeExpressions, transform } from './compile.js';
 export type * from './contracts.js';
 export type { ExpressionTable } from './precompiled.js';
 export { expressionKey, precompiled } from './precompiled.js';

package/dist/kernel/index.js

@@ -1,7 +1,7 @@
 import { camel, kebab, pascal, recase, snake } from "../lib/casing.js";
 import { expand, isPlain, toPredicate } from "../lib/objects.js";
-import { debounce, delay, throttle, toMs, withTiming, withViewTransition } from "../lib/schedule.js";
-import { compile, functionCompiler, rewriteActions, runtimeExpressions, splitStatements } from "./compile.js";
+import { debounce, delay, throttle, toMs, withTiming } from "../lib/schedule.js";
+import { compile, compileBody, functionCompiler, runtimeExpressions, transform } from "./compile.js";
 import { expressionKey, precompiled } from "./precompiled.js";
 import { batch, Computed, computed, effect, flush, onSettled, Signal, signal, untracked } from "./reactive.js";
 import { createRuntime, parseAttr } from "./runtime.js";
@@ -23,6 +23,7 @@ export {
   batch,
   camel,
   compile,
+  compileBody,
   computed,
   createRuntime,
   createSigmx,
@@ -42,16 +43,14 @@ export {
   pascal,
   precompiled,
   recase,
-  rewriteActions,
   runtimeExpressions,
   signal,
   snake,
-  splitStatements,
   throttle,
   toMs,
   toPredicate,
+  transform,
   untracked,
-  withTiming,
-  withViewTransition
+  withTiming
 };
 //# sourceMappingURL=index.js.map

package/dist/kernel/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/kernel/index.ts"],
-  "sourcesContent": ["export { camel, kebab, pascal, recase, snake } from '../lib/casing.js';\nexport type { Filter } from '../lib/objects.js';\nexport { expand, isPlain, toPredicate } from '../lib/objects.js';\nexport { debounce, delay, throttle, toMs, withTiming, withViewTransition } from '../lib/schedule.js';\nexport type { Compiler } from './compile.js';\nexport { compile, functionCompiler, rewriteActions, runtimeExpressions, splitStatements } from './compile.js';\nexport type * from './contracts.js';\nexport type { ExpressionTable } from './precompiled.js';\nexport { expressionKey, precompiled } from './precompiled.js';\nexport { batch, Computed, computed, effect, flush, onSettled, Signal, signal, untracked } from './reactive.js';\nexport { createRuntime, parseAttr } from './runtime.js';\nexport type { Patch, Store } from './state.js';\nexport { createStore } from './state.js';\n\nimport { functionCompiler, runtimeExpressions } from './compile.js';\nimport type { ActionPlugin, AttributePlugin, HandlerPlugin, Sigmx, SigmxOptions } from './contracts.js';\nimport { createRuntime } from './runtime.js';\n\n/** Create an instance. Expressions compile at runtime unless you pass `expressions` (see `precompiled`). */\nexport const createSigmx = (options: SigmxOptions = {}): Sigmx =>\n  createRuntime({\n    ...options,\n    expressions: options.expressions ?? runtimeExpressions(options.compile ?? functionCompiler),\n  });\n\nexport const attribute = (p: Omit<AttributePlugin, 'type'>): AttributePlugin => ({ type: 'attribute', ...p });\nexport const action = (p: Omit<ActionPlugin, 'type'>): ActionPlugin => ({ type: 'action', ...p });\nexport const handler = (p: Omit<HandlerPlugin, 'type'>): HandlerPlugin => ({ type: 'handler', ...p });\n"],
-  "mappings": "AAAA,SAAS,OAAO,OAAO,QAAQ,QAAQ,aAAa;AAEpD,SAAS,QAAQ,SAAS,mBAAmB;AAC7C,SAAS,UAAU,OAAO,UAAU,MAAM,YAAY,0BAA0B;AAEhF,SAAS,SAAS,kBAAkB,gBAAgB,oBAAoB,uBAAuB;AAG/F,SAAS,eAAe,mBAAmB;AAC3C,SAAS,OAAO,UAAU,UAAU,QAAQ,OAAO,WAAW,QAAQ,QAAQ,iBAAiB;AAC/F,SAAS,eAAe,iBAAiB;AAEzC,SAAS,mBAAmB;AAE5B,SAAS,oBAAAA,mBAAkB,sBAAAC,2BAA0B;AAErD,SAAS,iBAAAC,sBAAqB;AAGvB,MAAM,cAAc,CAAC,UAAwB,CAAC,MACnDA,eAAc;AAAA,EACZ,GAAG;AAAA,EACH,aAAa,QAAQ,eAAeD,oBAAmB,QAAQ,WAAWD,iBAAgB;AAC5F,CAAC;AAEI,MAAM,YAAY,CAAC,OAAuD,EAAE,MAAM,aAAa,GAAG,EAAE;AACpG,MAAM,SAAS,CAAC,OAAiD,EAAE,MAAM,UAAU,GAAG,EAAE;AACxF,MAAM,UAAU,CAAC,OAAmD,EAAE,MAAM,WAAW,GAAG,EAAE;",
+  "sourcesContent": ["export { camel, kebab, pascal, recase, snake } from '../lib/casing.js';\nexport type { Filter } from '../lib/objects.js';\nexport { expand, isPlain, toPredicate } from '../lib/objects.js';\nexport { debounce, delay, throttle, toMs, withTiming } from '../lib/schedule.js';\nexport type { Compiler } from './compile.js';\nexport { compile, compileBody, functionCompiler, runtimeExpressions, transform } from './compile.js';\nexport type * from './contracts.js';\nexport type { ExpressionTable } from './precompiled.js';\nexport { expressionKey, precompiled } from './precompiled.js';\nexport { batch, Computed, computed, effect, flush, onSettled, Signal, signal, untracked } from './reactive.js';\nexport { createRuntime, parseAttr } from './runtime.js';\nexport type { Patch, Store } from './state.js';\nexport { createStore } from './state.js';\n\nimport { functionCompiler, runtimeExpressions } from './compile.js';\nimport type { ActionPlugin, AttributePlugin, HandlerPlugin, Sigmx, SigmxOptions } from './contracts.js';\nimport { createRuntime } from './runtime.js';\n\n/** Create an instance. Expressions compile at runtime unless you pass `expressions` (see `precompiled`). */\nexport const createSigmx = (options: SigmxOptions = {}): Sigmx =>\n  createRuntime({\n    ...options,\n    expressions: options.expressions ?? runtimeExpressions(options.compile ?? functionCompiler),\n  });\n\nexport const attribute = (p: Omit<AttributePlugin, 'type'>): AttributePlugin => ({ type: 'attribute', ...p });\nexport const action = (p: Omit<ActionPlugin, 'type'>): ActionPlugin => ({ type: 'action', ...p });\nexport const handler = (p: Omit<HandlerPlugin, 'type'>): HandlerPlugin => ({ type: 'handler', ...p });\n"],
+  "mappings": "AAAA,SAAS,OAAO,OAAO,QAAQ,QAAQ,aAAa;AAEpD,SAAS,QAAQ,SAAS,mBAAmB;AAC7C,SAAS,UAAU,OAAO,UAAU,MAAM,kBAAkB;AAE5D,SAAS,SAAS,aAAa,kBAAkB,oBAAoB,iBAAiB;AAGtF,SAAS,eAAe,mBAAmB;AAC3C,SAAS,OAAO,UAAU,UAAU,QAAQ,OAAO,WAAW,QAAQ,QAAQ,iBAAiB;AAC/F,SAAS,eAAe,iBAAiB;AAEzC,SAAS,mBAAmB;AAE5B,SAAS,oBAAAA,mBAAkB,sBAAAC,2BAA0B;AAErD,SAAS,iBAAAC,sBAAqB;AAGvB,MAAM,cAAc,CAAC,UAAwB,CAAC,MACnDA,eAAc;AAAA,EACZ,GAAG;AAAA,EACH,aAAa,QAAQ,eAAeD,oBAAmB,QAAQ,WAAWD,iBAAgB;AAC5F,CAAC;AAEI,MAAM,YAAY,CAAC,OAAuD,EAAE,MAAM,aAAa,GAAG,EAAE;AACpG,MAAM,SAAS,CAAC,OAAiD,EAAE,MAAM,UAAU,GAAG,EAAE;AACxF,MAAM,UAAU,CAAC,OAAmD,EAAE,MAAM,WAAW,GAAG,EAAE;",
   "names": ["functionCompiler", "runtimeExpressions", "createRuntime"]
 }

package/dist/kernel/precompile.d.ts

@@ -1,23 +1,21 @@
-/**
- * Rewrite `$name` and `$a.b` into `$.name` / `$.a.b` so the expression runs in strict mode without
- * `with`. Skips strings and comments, recurses into template-literal interpolations, and leaves
- * `$` alone, `$[...]` alone, and `obj.$prop` alone.
- */
-export declare const rewriteSignals: (src: string) => string;
-export declare const compileBody: (src: string, returns: boolean) => string;
 export type Extracted = {
     src: string;
     params: string[];
-    returns: boolean;
 };
 export declare const generateTable: (items: Extracted[]) => string;
 export type PluginMeta = {
     name: string;
-    returns?: boolean;
     args?: string[];
+    literal?: boolean;
 };
 /**
  * Find directive attributes with literal values in template source. Values must be plain quoted
- * strings; anything interpolated at render time is left to the runtime fallback.
+ * strings; anything interpolated at render time is left to the runtime fallback. Plugins whose value
+ * is a literal (mask, teleport, …) are skipped unless the attribute carries `__dynamic`.
  */
 export declare const extractExpressions: (source: string, plugins: PluginMeta[], prefixes?: string[]) => Extracted[];
+/**
+ * Keyed directive attributes whose key contains an uppercase letter. HTML lowercases attribute names,
+ * so `data-bind:firstName` reaches the runtime as `firstname`: write `data-bind:first-name`.
+ */
+export declare const lintSource: (source: string, prefixes?: string[]) => string[];

package/dist/kernel/precompile.js

@@ -1,80 +1,15 @@
-import { rewriteActions, splitStatements } from "./compile.js";
+import { compileBody, functionCompiler } from "./compile.js";
 import { expressionKey } from "./precompiled.js";
-const ident = /[A-Za-z0-9_$]/;
-const rewriteSignals = (src) => {
-  let out = "";
-  let i = 0;
-  const n = src.length;
-  const prevCode = () => {
-    for (let j = out.length - 1; j >= 0; j--) if (!/\s/.test(out[j])) return out[j];
-    return "";
-  };
-  while (i < n) {
-    const c = src[i];
-    const next = src[i + 1];
-    if (c === '"' || c === "'") {
-      let j = i + 1;
-      while (j < n && src[j] !== c) j += src[j] === "\\" ? 2 : 1;
-      out += src.slice(i, j + 1);
-      i = j + 1;
-    } else if (c === "`") {
-      out += c;
-      i++;
-      while (i < n && src[i] !== "`") {
-        if (src[i] === "\\") {
-          out += src.slice(i, i + 2);
-          i += 2;
-        } else if (src[i] === "$" && src[i + 1] === "{") {
-          let depth = 1;
-          let j = i + 2;
-          while (j < n && depth) {
-            if (src[j] === "{") depth++;
-            else if (src[j] === "}") depth--;
-            if (depth) j++;
-          }
-          out += `\${${rewriteSignals(src.slice(i + 2, j))}}`;
-          i = j + 1;
-        } else out += src[i++];
-      }
-      out += "`";
-      i++;
-    } else if (c === "/" && next === "/") {
-      const j = src.indexOf("\n", i);
-      i = j < 0 ? n : j;
-    } else if (c === "/" && next === "*") {
-      const j = src.indexOf("*/", i + 2);
-      i = j < 0 ? n : j + 2;
-    } else if (c === "$" && next !== void 0 && ident.test(next) && next !== "$" && prevCode() !== "." && !ident.test(out[out.length - 1] ?? "")) {
-      let j = i + 1;
-      while (j < n && ident.test(src[j])) j++;
-      out += `$.${src.slice(i + 1, j)}`;
-      i = j;
-    } else {
-      out += c;
-      i++;
-    }
-  }
-  return out;
-};
-const compileBody = (src, returns) => {
-  const code = rewriteSignals(rewriteActions(src.trim()));
-  if (!returns) return code;
-  const parts = splitStatements(code);
-  const last = parts.pop() ?? "";
-  return `${parts.length ? `${parts.join(";")};` : ""}return (${last}
-)`;
-};
 const generateTable = (items) => {
   const seen = /* @__PURE__ */ new Set();
   const lines = [];
-  for (const { src, params, returns } of items) {
-    const key = expressionKey(src, params, returns);
+  for (const { src, params } of items) {
+    const key = expressionKey(src);
     if (seen.has(key)) continue;
     seen.add(key);
     let body;
     try {
-      body = compileBody(src, returns);
-      Function("$", "__a", ...params, body);
+      [body] = compileBody(functionCompiler, src, params);
     } catch {
       continue;
     }
@@ -93,7 +28,15 @@ const entities = {
   "&gt;": ">",
   "&amp;": "&"
 };
-const decode = (s) => s.replace(/&(quot|#39|apos|lt|gt|amp);/g, (m) => entities[m]);
+const decode = (s) => s.replace(
+  /&(?:quot|apos|lt|gt|amp|#\d+|#x[\da-f]+);/gi,
+  (m) => m[1] === "#" ? String.fromCodePoint(
+    Number.parseInt(
+      m[2] === "x" || m[2] === "X" ? m.slice(3, -1) : m.slice(2, -1),
+      m[2] === "x" || m[2] === "X" ? 16 : 10
+    )
+  ) : entities[m.toLowerCase()] ?? m
+);
 const extractExpressions = (source, plugins, prefixes = ["data-"]) => {
   const byName = new Map(plugins.map((p) => [p.name, p]));
   const out = [];
@@ -103,16 +46,23 @@ const extractExpressions = (source, plugins, prefixes = ["data-"]) => {
     const value = decode(m[2] ?? m[3] ?? "");
     const prefix = prefixes.find((p) => attr.startsWith(p));
     if (!prefix || !value.trim()) continue;
-    const plugin = byName.get(attr.slice(prefix.length).split("__")[0].split(":")[0]);
-    if (!plugin) continue;
-    out.push({ src: value, params: ["el", "evt", ...plugin.args ?? []], returns: plugin.returns ?? true });
+    const [head, ...mods] = attr.slice(prefix.length).split("__");
+    const plugin = byName.get(head.split(":")[0]);
+    if (!plugin || plugin.literal && !mods.some((x) => x.split(".")[0] === "dynamic")) continue;
+    out.push({ src: value, params: ["el", "evt", ...plugin.args ?? []] });
   }
   return out;
 };
+const lintSource = (source, prefixes = ["data-"]) => {
+  const out = [];
+  for (const p of prefixes)
+    for (const m of source.matchAll(new RegExp(`(?<![\\w-])(${p}[a-z-]+:[^\\s="'<>]*[A-Z][^\\s="'<>]*)`, "g")))
+      out.push(`${m[1]}: attribute names are lowercased by HTML; write the key in kebab-case`);
+  return out;
+};
 export {
-  compileBody,
   extractExpressions,
   generateTable,
-  rewriteSignals
+  lintSource
 };
 //# sourceMappingURL=precompile.js.map