sigmx 0.1.0 → 0.2.0

package/dist/kernel/index.d.ts

@@ -1,20 +1,19 @@
-export { createRuntime, parseAttr } from './runtime.js';
-export { compile, functionCompiler, rewriteActions, runtimeExpressions, splitStatements } from './compile.js';
-export { expressionKey, precompiled } from './precompiled.js';
-export type { ExpressionTable } from './precompiled.js';
+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 } from '../lib/schedule.js';
 export type { Compiler } from './compile.js';
-export { Computed, Signal, batch, computed, effect, flush, onSettled, signal, untracked } from './reactive.js';
-export { createStore } from './state.js';
-export type { Patch, Store } from './state.js';
+export { compile, compileBody, functionCompiler, runtimeExpressions, transform } from './compile.js';
 export type * from './contracts.js';
-export { expand, isPlain, toPredicate } from '../lib/objects.js';
-export type { Filter } from '../lib/objects.js';
-export { camel, kebab, pascal, recase, snake } from '../lib/casing.js';
-export { debounce, delay, throttle, toMs, withTiming, withViewTransition } from '../lib/schedule.js';
+export type { ExpressionTable } from './precompiled.js';
+export { expressionKey, precompiled } from './precompiled.js';
+export { batch, Computed, computed, effect, flush, onSettled, Signal, signal, untracked } from './reactive.js';
+export { createRuntime, parseAttr } from './runtime.js';
+export type { Patch, Store } from './state.js';
+export { createStore } from './state.js';
 import type { ActionPlugin, AttributePlugin, HandlerPlugin, Sigmx, SigmxOptions } from './contracts.js';
 /** Create an instance. Expressions compile at runtime unless you pass `expressions` (see `precompiled`). */
 export declare const createSigmx: (options?: SigmxOptions) => Sigmx;
-/** Type a plugin definition. Pure: registration is `createSigmx({ plugins })` or `sigmx.use()`. */
 export declare const attribute: (p: Omit<AttributePlugin, "type">) => AttributePlugin;
 export declare const action: (p: Omit<ActionPlugin, "type">) => ActionPlugin;
 export declare const handler: (p: Omit<HandlerPlugin, "type">) => HandlerPlugin;

package/dist/kernel/index.js

@@ -1,14 +1,17 @@
-import { createRuntime, parseAttr } from "./runtime.js";
-import { compile, functionCompiler, rewriteActions, runtimeExpressions, splitStatements } from "./compile.js";
+import { camel, kebab, pascal, recase, snake } from "../lib/casing.js";
+import { expand, isPlain, toPredicate } from "../lib/objects.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 { Computed, Signal, batch, computed, effect, flush, onSettled, signal, untracked } from "./reactive.js";
+import { batch, Computed, computed, effect, flush, onSettled, Signal, signal, untracked } from "./reactive.js";
+import { createRuntime, parseAttr } from "./runtime.js";
 import { createStore } from "./state.js";
-import { expand, isPlain, toPredicate } from "../lib/objects.js";
-import { camel, kebab, pascal, recase, snake } from "../lib/casing.js";
-import { debounce, delay, throttle, toMs, withTiming, withViewTransition } from "../lib/schedule.js";
-import { createRuntime as createRuntime2 } from "./runtime.js";
 import { functionCompiler as functionCompiler2, runtimeExpressions as runtimeExpressions2 } from "./compile.js";
-const createSigmx = (options = {}) => createRuntime2({ ...options, expressions: options.expressions ?? runtimeExpressions2(options.compile ?? functionCompiler2) });
+import { createRuntime as createRuntime2 } from "./runtime.js";
+const createSigmx = (options = {}) => createRuntime2({
+  ...options,
+  expressions: options.expressions ?? runtimeExpressions2(options.compile ?? functionCompiler2)
+});
 const attribute = (p) => ({ type: "attribute", ...p });
 const action = (p) => ({ type: "action", ...p });
 const handler = (p) => ({ type: "handler", ...p });
@@ -20,6 +23,7 @@ export {
   batch,
   camel,
   compile,
+  compileBody,
   computed,
   createRuntime,
   createSigmx,
@@ -39,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 { createRuntime, parseAttr } from './runtime.js'\nexport { compile, functionCompiler, rewriteActions, runtimeExpressions, splitStatements } from './compile.js'\nexport { expressionKey, precompiled } from './precompiled.js'\nexport type { ExpressionTable } from './precompiled.js'\nexport type { Compiler } from './compile.js'\nexport { Computed, Signal, batch, computed, effect, flush, onSettled, signal, untracked } from './reactive.js'\nexport { createStore } from './state.js'\nexport type { Patch, Store } from './state.js'\nexport type * from './contracts.js'\nexport { expand, isPlain, toPredicate } from '../lib/objects.js'\nexport type { Filter } from '../lib/objects.js'\nexport { camel, kebab, pascal, recase, snake } from '../lib/casing.js'\nexport { debounce, delay, throttle, toMs, withTiming, withViewTransition } from '../lib/schedule.js'\n\nimport type { ActionPlugin, AttributePlugin, HandlerPlugin, Sigmx, SigmxOptions } from './contracts.js'\nimport { createRuntime } from './runtime.js'\nimport { functionCompiler, runtimeExpressions } from './compile.js'\n\n/** Create an instance. Expressions compile at runtime unless you pass `expressions` (see `precompiled`). */\nexport const createSigmx = (options: SigmxOptions = {}): Sigmx =>\n  createRuntime({ ...options, expressions: options.expressions ?? runtimeExpressions(options.compile ?? functionCompiler) })\n\n/** Type a plugin definition. Pure: registration is `createSigmx({ plugins })` or `sigmx.use()`. */\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,eAAe,iBAAiB;AACzC,SAAS,SAAS,kBAAkB,gBAAgB,oBAAoB,uBAAuB;AAC/F,SAAS,eAAe,mBAAmB;AAG3C,SAAS,UAAU,QAAQ,OAAO,UAAU,QAAQ,OAAO,WAAW,QAAQ,iBAAiB;AAC/F,SAAS,mBAAmB;AAG5B,SAAS,QAAQ,SAAS,mBAAmB;AAE7C,SAAS,OAAO,OAAO,QAAQ,QAAQ,aAAa;AACpD,SAAS,UAAU,OAAO,UAAU,MAAM,YAAY,0BAA0B;AAGhF,SAAS,iBAAAA,sBAAqB;AAC9B,SAAS,oBAAAC,mBAAkB,sBAAAC,2BAA0B;AAG9C,MAAM,cAAc,CAAC,UAAwB,CAAC,MACnDF,eAAc,EAAE,GAAG,SAAS,aAAa,QAAQ,eAAeE,oBAAmB,QAAQ,WAAWD,iBAAgB,EAAE,CAAC;AAGpH,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": ["createRuntime", "functionCompiler", "runtimeExpressions"]
+  "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,25 +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;
-/** The strict-mode function body for one expression: same semantics as the runtime compiler. */
-export declare const compileBody: (src: string, returns: boolean) => string;
 export type Extracted = {
     src: string;
     params: string[];
-    returns: boolean;
 };
-/** JavaScript source for a module exporting `table`, from a list of extracted expressions. */
 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;
     }
@@ -85,8 +20,23 @@ ${lines.join("\n")}
 }
 `;
 };
-const entities = { "&quot;": '"', "&#39;": "'", "&apos;": "'", "&lt;": "<", "&gt;": ">", "&amp;": "&" };
-const decode = (s) => s.replace(/&(quot|#39|apos|lt|gt|amp);/g, (m) => entities[m]);
+const entities = {
+  "&quot;": '"',
+  "&#39;": "'",
+  "&apos;": "'",
+  "&lt;": "<",
+  "&gt;": ">",
+  "&amp;": "&"
+};
+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 = [];
@@ -96,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

package/dist/kernel/precompile.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/kernel/precompile.ts"],
-  "sourcesContent": ["// Build-time expression compiler. Not for the browser: import it from a Vite/Astro plugin.\nimport { rewriteActions, splitStatements } from './compile.js'\nimport { expressionKey } from './precompiled.js'\n\nconst ident = /[A-Za-z0-9_$]/\n\n/**\n * Rewrite `$name` and `$a.b` into `$.name` / `$.a.b` so the expression runs in strict mode without\n * `with`. Skips strings and comments, recurses into template-literal interpolations, and leaves\n * `$` alone, `$[...]` alone, and `obj.$prop` alone.\n */\nexport const rewriteSignals = (src: string): string => {\n  let out = ''\n  let i = 0\n  const n = src.length\n  const prevCode = () => {\n    for (let j = out.length - 1; j >= 0; j--) if (!/\\s/.test(out[j])) return out[j]\n    return ''\n  }\n  while (i < n) {\n    const c = src[i]\n    const next = 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          let depth = 1\n          let j = i + 2\n          while (j < n && depth) {\n            if (src[j] === '{') depth++\n            else if (src[j] === '}') depth--\n            if (depth) j++\n          }\n          out += '${' + rewriteSignals(src.slice(i + 2, j)) + '}'\n          i = j + 1\n        } else out += src[i++]\n      }\n      out += '`'\n      i++\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 if (c === '$' && next !== undefined && ident.test(next) && next !== '$' && prevCode() !== '.' && !ident.test(out[out.length - 1] ?? '')) {\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 {\n      out += c\n      i++\n    }\n  }\n  return out\n}\n\n/** The strict-mode function body for one expression: same semantics as the runtime compiler. */\nexport const compileBody = (src: string, returns: boolean): string => {\n  const code = rewriteSignals(rewriteActions(src.trim()))\n  if (!returns) return code\n  const parts = splitStatements(code)\n  const last = parts.pop() ?? ''\n  return `${parts.length ? parts.join(';') + ';' : ''}return (${last}\\n)`\n}\n\nexport type Extracted = { src: string; params: string[]; returns: boolean }\n\n/** JavaScript source for a module exporting `table`, from a list of extracted expressions. */\nexport const generateTable = (items: Extracted[]): string => {\n  const seen = new Set<string>()\n  const lines: string[] = []\n  for (const { src, params, returns } of items) {\n    const key = expressionKey(src, params, returns)\n    if (seen.has(key)) continue\n    seen.add(key)\n    let body: string\n    try {\n      body = compileBody(src, returns)\n      Function('$', '__a', ...params, body) // syntax check at build time\n    } catch {\n      continue // leave it to the runtime fallback (or fail there)\n    }\n    lines.push(`  ${JSON.stringify(key)}: function($, __a, ${params.join(', ')}) { ${body} },`)\n  }\n  return `export const table = {\\n${lines.join('\\n')}\\n}\\n`\n}\n\nconst entities: Record<string, string> = { '&quot;': '\"', '&#39;': \"'\", '&apos;': \"'\", '&lt;': '<', '&gt;': '>', '&amp;': '&' }\nconst decode = (s: string) => s.replace(/&(quot|#39|apos|lt|gt|amp);/g, (m) => entities[m])\n\nexport type PluginMeta = { name: string; returns?: boolean; args?: string[] }\n\n/**\n * Find directive attributes with literal values in template source. Values must be plain quoted\n * strings; anything interpolated at render time is left to the runtime fallback.\n */\nexport const extractExpressions = (source: string, plugins: PluginMeta[], prefixes: string[] = ['data-']): Extracted[] => {\n  const byName = new Map(plugins.map((p) => [p.name, p]))\n  const out: Extracted[] = []\n  const re = /([a-z][\\w-]*(?::[^\\s=\"'<>]+)?(?:__[^\\s=\"'<>]+)*)=(?:\"([^\"]*)\"|'([^']*)')/g\n  for (const m of source.matchAll(re)) {\n    const attr = m[1]\n    const value = decode(m[2] ?? m[3] ?? '')\n    const prefix = prefixes.find((p) => attr.startsWith(p))\n    if (!prefix || !value.trim()) continue\n    const plugin = byName.get(attr.slice(prefix.length).split('__')[0].split(':')[0])\n    if (!plugin) continue\n    out.push({ src: value, params: ['el', 'evt', ...(plugin.args ?? [])], returns: plugin.returns ?? true })\n  }\n  return out\n}\n"],
-  "mappings": "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",
+  "sourcesContent": ["// Build-time expression compiler. Not for the browser: import it from a Vite/Astro plugin.\n// It emits the very same strict-mode bodies the runtime compiles, keyed by source text.\nimport { compileBody, functionCompiler } from './compile.js';\nimport { expressionKey } from './precompiled.js';\n\nexport type Extracted = { src: string; params: string[] };\n\nexport const generateTable = (items: Extracted[]): string => {\n  const seen = new Set<string>();\n  const lines: string[] = [];\n  for (const { src, params } of items) {\n    const key = expressionKey(src);\n    if (seen.has(key)) continue;\n    seen.add(key);\n    let body: string;\n    try {\n      [body] = compileBody(functionCompiler, src, params); // also the syntax check\n    } catch {\n      continue; // leave it to the runtime fallback (or fail there)\n    }\n    lines.push(`  ${JSON.stringify(key)}: function($, __a, ${params.join(', ')}) { ${body} },`);\n  }\n  return `export const table = {\\n${lines.join('\\n')}\\n}\\n`;\n};\n\nconst entities: Record<string, string> = {\n  '&quot;': '\"',\n  '&#39;': \"'\",\n  '&apos;': \"'\",\n  '&lt;': '<',\n  '&gt;': '>',\n  '&amp;': '&',\n};\nconst decode = (s: string) =>\n  s.replace(/&(?:quot|apos|lt|gt|amp|#\\d+|#x[\\da-f]+);/gi, (m) =>\n    m[1] === '#'\n      ? String.fromCodePoint(\n          Number.parseInt(\n            m[2] === 'x' || m[2] === 'X' ? m.slice(3, -1) : m.slice(2, -1),\n            m[2] === 'x' || m[2] === 'X' ? 16 : 10,\n          ),\n        )\n      : (entities[m.toLowerCase()] ?? m),\n  );\n\nexport type PluginMeta = { name: string; args?: string[]; literal?: boolean };\n\n/**\n * Find directive attributes with literal values in template source. Values must be plain quoted\n * strings; anything interpolated at render time is left to the runtime fallback. Plugins whose value\n * is a literal (mask, teleport, \u2026) are skipped unless the attribute carries `__dynamic`.\n */\nexport const extractExpressions = (\n  source: string,\n  plugins: PluginMeta[],\n  prefixes: string[] = ['data-'],\n): Extracted[] => {\n  const byName = new Map(plugins.map((p) => [p.name, p]));\n  const out: Extracted[] = [];\n  const re = /([a-z][\\w-]*(?::[^\\s=\"'<>]+)?(?:__[^\\s=\"'<>]+)*)=(?:\"([^\"]*)\"|'([^']*)')/g;\n  for (const m of source.matchAll(re)) {\n    const attr = m[1];\n    const value = decode(m[2] ?? m[3] ?? '');\n    const prefix = prefixes.find((p) => attr.startsWith(p));\n    if (!prefix || !value.trim()) continue;\n    const [head, ...mods] = attr.slice(prefix.length).split('__');\n    const plugin = byName.get(head.split(':')[0]);\n    if (!plugin || (plugin.literal && !mods.some((x) => x.split('.')[0] === 'dynamic'))) continue;\n    out.push({ src: value, params: ['el', 'evt', ...(plugin.args ?? [])] });\n  }\n  return out;\n};\n\n/**\n * Keyed directive attributes whose key contains an uppercase letter. HTML lowercases attribute names,\n * so `data-bind:firstName` reaches the runtime as `firstname`: write `data-bind:first-name`.\n */\nexport const lintSource = (source: string, prefixes: string[] = ['data-']): string[] => {\n  const out: string[] = [];\n  for (const p of prefixes)\n    for (const m of source.matchAll(new RegExp(`(?<![\\\\w-])(${p}[a-z-]+:[^\\\\s=\"'<>]*[A-Z][^\\\\s=\"'<>]*)`, 'g')))\n      out.push(`${m[1]}: attribute names are lowercased by HTML; write the key in kebab-case`);\n  return out;\n};\n"],
+  "mappings": "AAEA,SAAS,aAAa,wBAAwB;AAC9C,SAAS,qBAAqB;AAIvB,MAAM,gBAAgB,CAAC,UAA+B;AAC3D,QAAM,OAAO,oBAAI,IAAY;AAC7B,QAAM,QAAkB,CAAC;AACzB,aAAW,EAAE,KAAK,OAAO,KAAK,OAAO;AACnC,UAAM,MAAM,cAAc,GAAG;AAC7B,QAAI,KAAK,IAAI,GAAG,EAAG;AACnB,SAAK,IAAI,GAAG;AACZ,QAAI;AACJ,QAAI;AACF,OAAC,IAAI,IAAI,YAAY,kBAAkB,KAAK,MAAM;AAAA,IACpD,QAAQ;AACN;AAAA,IACF;AACA,UAAM,KAAK,KAAK,KAAK,UAAU,GAAG,CAAC,sBAAsB,OAAO,KAAK,IAAI,CAAC,OAAO,IAAI,KAAK;AAAA,EAC5F;AACA,SAAO;AAAA,EAA2B,MAAM,KAAK,IAAI,CAAC;AAAA;AAAA;AACpD;AAEA,MAAM,WAAmC;AAAA,EACvC,UAAU;AAAA,EACV,SAAS;AAAA,EACT,UAAU;AAAA,EACV,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,SAAS;AACX;AACA,MAAM,SAAS,CAAC,MACd,EAAE;AAAA,EAAQ;AAAA,EAA+C,CAAC,MACxD,EAAE,CAAC,MAAM,MACL,OAAO;AAAA,IACL,OAAO;AAAA,MACL,EAAE,CAAC,MAAM,OAAO,EAAE,CAAC,MAAM,MAAM,EAAE,MAAM,GAAG,EAAE,IAAI,EAAE,MAAM,GAAG,EAAE;AAAA,MAC7D,EAAE,CAAC,MAAM,OAAO,EAAE,CAAC,MAAM,MAAM,KAAK;AAAA,IACtC;AAAA,EACF,IACC,SAAS,EAAE,YAAY,CAAC,KAAK;AACpC;AASK,MAAM,qBAAqB,CAChC,QACA,SACA,WAAqB,CAAC,OAAO,MACb;AAChB,QAAM,SAAS,IAAI,IAAI,QAAQ,IAAI,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;AACtD,QAAM,MAAmB,CAAC;AAC1B,QAAM,KAAK;AACX,aAAW,KAAK,OAAO,SAAS,EAAE,GAAG;AACnC,UAAM,OAAO,EAAE,CAAC;AAChB,UAAM,QAAQ,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE;AACvC,UAAM,SAAS,SAAS,KAAK,CAAC,MAAM,KAAK,WAAW,CAAC,CAAC;AACtD,QAAI,CAAC,UAAU,CAAC,MAAM,KAAK,EAAG;AAC9B,UAAM,CAAC,MAAM,GAAG,IAAI,IAAI,KAAK,MAAM,OAAO,MAAM,EAAE,MAAM,IAAI;AAC5D,UAAM,SAAS,OAAO,IAAI,KAAK,MAAM,GAAG,EAAE,CAAC,CAAC;AAC5C,QAAI,CAAC,UAAW,OAAO,WAAW,CAAC,KAAK,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,EAAE,CAAC,MAAM,SAAS,EAAI;AACrF,QAAI,KAAK,EAAE,KAAK,OAAO,QAAQ,CAAC,MAAM,OAAO,GAAI,OAAO,QAAQ,CAAC,CAAE,EAAE,CAAC;AAAA,EACxE;AACA,SAAO;AACT;AAMO,MAAM,aAAa,CAAC,QAAgB,WAAqB,CAAC,OAAO,MAAgB;AACtF,QAAM,MAAgB,CAAC;AACvB,aAAW,KAAK;AACd,eAAW,KAAK,OAAO,SAAS,IAAI,OAAO,eAAe,CAAC,0CAA0C,GAAG,CAAC;AACvG,UAAI,KAAK,GAAG,EAAE,CAAC,CAAC,uEAAuE;AAC3F,SAAO;AACT;",
   "names": []
 }

package/dist/kernel/precompiled.d.ts

@@ -1,10 +1,13 @@
 import type { ExpressionCompiler } from './contracts.js';
 export type ExpressionTable = Record<string, (root: any, actions: any, el: any, evt: any, ...args: any[]) => any>;
-/** Key used by the build plugin and the lookup: returns flag, parameter names, trimmed source. */
-export declare const expressionKey: (src: string, params: string[], returns: boolean) => string;
 /**
- * Look expressions up in a table generated at build time (see `sigmx/precompile`). Precompiled functions
- * receive the root store proxy as `$` instead of a `with` scope. Pass a `fallback` (for example
+ * Key used by the build plugin and the lookup: the trimmed source text. Parameter names are not part
+ * of it, so a plugin gaining an argument (arguments are only ever appended) keeps old tables valid.
+ */
+export declare const expressionKey: (src: string) => string;
+/**
+ * Look expressions up in a table generated at build time (see `sigmx/precompile`). Table functions
+ * take the root store proxy as `$`, exactly like runtime-compiled ones. Pass a `fallback` (for example
  * `runtimeExpressions(functionCompiler)`) for markup assembled at runtime; omit it and the runtime
  * compiler is not bundled at all.
  */

package/dist/kernel/precompiled.js

@@ -1,10 +1,10 @@
-const expressionKey = (src, params, returns) => `${+returns}|${params.join()}|${src.trim()}`;
-const precompiled = (table, fallback, onMiss) => (src, params, returns) => {
-  const fn = table[expressionKey(src, params, returns)];
-  if (fn) return ((store, actions, el, evt, ...args) => fn(store.$, actions, el, evt, ...args));
+const expressionKey = (src) => src.trim();
+const precompiled = (table, fallback, onMiss) => (src, params) => {
+  const fn = table[expressionKey(src)];
+  if (fn) return ((store, actions, ...rest) => fn(store.$, actions, ...rest));
   onMiss?.(src);
   if (!fallback) throw new Error(`expression not precompiled: ${src}`);
-  return fallback(src, params, returns);
+  return fallback(src, params);
 };
 export {
   expressionKey,

package/dist/kernel/precompiled.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/kernel/precompiled.ts"],
-  "sourcesContent": ["import type { Evaluator, ExpressionCompiler } from './contracts.js'\n\nexport type ExpressionTable = Record<string, (root: any, actions: any, el: any, evt: any, ...args: any[]) => any>\n\n/** Key used by the build plugin and the lookup: returns flag, parameter names, trimmed source. */\nexport const expressionKey = (src: string, params: string[], returns: boolean): string => `${+returns}|${params.join()}|${src.trim()}`\n\n/**\n * Look expressions up in a table generated at build time (see `sigmx/precompile`). Precompiled functions\n * receive the root store proxy as `$` instead of a `with` scope. Pass a `fallback` (for example\n * `runtimeExpressions(functionCompiler)`) for markup assembled at runtime; omit it and the runtime\n * compiler is not bundled at all.\n */\nexport const precompiled =\n  (table: ExpressionTable, fallback?: ExpressionCompiler, onMiss?: (src: string) => void): ExpressionCompiler =>\n  (src, params, returns) => {\n    const fn = table[expressionKey(src, params, returns)]\n    if (fn) return ((store, actions, el, evt, ...args) => fn(store.$, actions, el, evt, ...args)) as Evaluator\n    onMiss?.(src)\n    if (!fallback) throw new Error(`expression not precompiled: ${src}`)\n    return fallback(src, params, returns)\n  }\n"],
-  "mappings": "AAKO,MAAM,gBAAgB,CAAC,KAAa,QAAkB,YAA6B,GAAG,CAAC,OAAO,IAAI,OAAO,KAAK,CAAC,IAAI,IAAI,KAAK,CAAC;AAQ7H,MAAM,cACX,CAAC,OAAwB,UAA+B,WACxD,CAAC,KAAK,QAAQ,YAAY;AACxB,QAAM,KAAK,MAAM,cAAc,KAAK,QAAQ,OAAO,CAAC;AACpD,MAAI,GAAI,SAAQ,CAAC,OAAO,SAAS,IAAI,QAAQ,SAAS,GAAG,MAAM,GAAG,SAAS,IAAI,KAAK,GAAG,IAAI;AAC3F,WAAS,GAAG;AACZ,MAAI,CAAC,SAAU,OAAM,IAAI,MAAM,+BAA+B,GAAG,EAAE;AACnE,SAAO,SAAS,KAAK,QAAQ,OAAO;AACtC;",
+  "sourcesContent": ["import type { Evaluator, ExpressionCompiler } from './contracts.js';\n\nexport type ExpressionTable = Record<string, (root: any, actions: any, el: any, evt: any, ...args: any[]) => any>;\n\n/**\n * Key used by the build plugin and the lookup: the trimmed source text. Parameter names are not part\n * of it, so a plugin gaining an argument (arguments are only ever appended) keeps old tables valid.\n */\nexport const expressionKey = (src: string): string => src.trim();\n\n/**\n * Look expressions up in a table generated at build time (see `sigmx/precompile`). Table functions\n * take the root store proxy as `$`, exactly like runtime-compiled ones. Pass a `fallback` (for example\n * `runtimeExpressions(functionCompiler)`) for markup assembled at runtime; omit it and the runtime\n * compiler is not bundled at all.\n */\nexport const precompiled =\n  (table: ExpressionTable, fallback?: ExpressionCompiler, onMiss?: (src: string) => void): ExpressionCompiler =>\n  (src, params) => {\n    const fn = table[expressionKey(src)];\n    if (fn) return ((store, actions, ...rest) => fn(store.$, actions, ...rest)) as Evaluator;\n    onMiss?.(src);\n    if (!fallback) throw new Error(`expression not precompiled: ${src}`);\n    return fallback(src, params);\n  };\n"],
+  "mappings": "AAQO,MAAM,gBAAgB,CAAC,QAAwB,IAAI,KAAK;AAQxD,MAAM,cACX,CAAC,OAAwB,UAA+B,WACxD,CAAC,KAAK,WAAW;AACf,QAAM,KAAK,MAAM,cAAc,GAAG,CAAC;AACnC,MAAI,GAAI,SAAQ,CAAC,OAAO,YAAY,SAAS,GAAG,MAAM,GAAG,SAAS,GAAG,IAAI;AACzE,WAAS,GAAG;AACZ,MAAI,CAAC,SAAU,OAAM,IAAI,MAAM,+BAA+B,GAAG,EAAE;AACnE,SAAO,SAAS,KAAK,MAAM;AAC7B;",
   "names": []
 }

package/dist/kernel/reactive.d.ts

@@ -3,27 +3,27 @@ interface Tracker {
     _invalidate(): void;
 }
 export declare class Signal<T> {
-    /** @internal */ _v: T;
-    /** @internal */ _ver: number;
-    /** @internal */ _subs: Set<Tracker>;
+    _v: T;
+    _ver: number;
+    _subs: Set<Tracker>;
     constructor(v: T);
     get value(): T;
     set value(x: T);
-    /** Read without subscribing. */
     peek(): T;
     /** Notify subscribers without replacing the value (after mutating an array or object in place). */
     bump(): void;
 }
 export declare class Computed<T> extends Signal<T> implements Tracker {
+    _fn: () => T;
     _deps: Map<Signal<any>, number>;
-    /** @internal */ _dirty: boolean;
-    /** @internal */ _fn: () => T;
+    _dirty: boolean;
     constructor(fn: () => T);
-    /** @internal */ _refresh(): void;
+    _refresh(): void;
     get value(): T;
     set value(_: T);
-    peek(): T;
     _invalidate(): void;
+    /** Unsubscribe from every dependency; the computed is no longer recalculated. Public: the store calls it. */
+    dispose(): void;
 }
 export declare const signal: <T>(value: T) => Signal<T>;
 export declare const computed: <T>(fn: () => T) => Computed<T>;
@@ -32,11 +32,13 @@ export declare const computed: <T>(fn: () => T) => Computed<T>;
  * effect are disposed when the parent re-runs. Returns a disposer.
  */
 export declare const effect: (fn: () => void, onError?: (e: unknown) => void) => (() => void);
-/** Coalesce many writes into one round of effect runs. */
+/**
+ * Like `effect`, but never owned by the effect that happens to be running: for long-lived effects
+ * such as mounted attributes, which must not die when an unrelated parent effect re-runs.
+ */
+export declare const rootEffect: (fn: () => void, onError?: (e: unknown) => void) => (() => void);
 export declare const batch: <R>(fn: () => R) => R;
-/** Read signals inside `fn` without subscribing the current effect to them. */
 export declare const untracked: <R>(fn: () => R) => R;
-/** Called after each flush once every queued effect has run. */
 export declare const onSettled: (fn: () => void) => (() => void);
 export declare const flush: () => void;
 export {};