@symbo.ls/utils 3.14.774 → 3.14.776

package/dist/esm/sharedLibraries.js

@@ -1 +1 @@
-import{isObject as a,isString as y}from"./types.js";const m="system",v="https://smbls-kv.nika-980.workers.dev",O="https://api.symbols.app";function f(n){const t=String(n||"").trim();if(!t)return{owner:m,key:"",full:""};let r=null,e=t;if(t.includes("/")){const o=t.indexOf("/");r=t.slice(0,o),e=t.slice(o+1)}e=e.replace(/\.symbo\.ls$/iu,""),r||(r=m);const s=e?`${r}/${e}`:"";return{owner:r,key:e,full:s}}const d=(n,t,r,e)=>{for(const s in t){const o=e?`${e}/${s}`:s;r&&r.has(o)||(s in n?a(n[s])&&a(t[s])&&d(n[s],t[s],r,o):n[s]=t[s])}},h=(n,t,r)=>{if(!a(n)||!t.size)return n;const e=`${r}/`;let s=!1;for(const i of t)if(i.startsWith(e)){s=!0;break}if(!s)return n;const o={};for(const i in n){if(!Object.prototype.hasOwnProperty.call(n,i))continue;const c=`${r}/${i}`;t.has(c)||(o[i]=h(n[i],t,c))}return o},j=new Set,F=new Set(["components","pages","functions","snippets","methods"]),b=(n,t)=>t===""&&F.has(n),w=["fontFamily","fontfamily","font_family","FONT_FAMILY"],R=n=>{const t=new Map;if(!a(n))return t;for(const r of w){const e=n[r];if(a(e))for(const s in e)!a(e[s])||!e[s].isDefault||(t.has(r)||t.set(r,new Set),t.get(r).add(s))}return t},U=(n,t)=>{for(const r of w){const e=n[r];if(!a(e))continue;const s=t.get(r);let o=null;for(const i in e){const c=e[i];if(!a(c)||!c.isDefault||s&&s.has(i))continue;const l={...c};delete l.isDefault,o||(o={...e}),o[i]=l}o&&(n[r]=o)}},E=n=>n.replace(/\.js$/iu,""),g=n=>{const t=new Set;if(!Array.isArray(n))return t;for(const r of n){if(!y(r))continue;const e=r.split("/").map(s=>E(s.trim())).filter(Boolean).join("/");e&&t.add(e)}return t},G=(n,t={})=>({library:n,ignoreList:Array.isArray(t.ignoreList)?t.ignoreList:[]}),k=n=>a(n)&&Array.isArray(n.ignoreList)&&("library"in n||"key"in n||"name"in n),B=n=>n.library!==void 0?n.library:n.key??n.name,P=(n,t,r)=>{const e=g(t.sharedLibIgnore);t.sharePages===!1&&e.add("pages");const s=e.size?new Set([...r,...e]):r;for(const o in t)if(Object.prototype.hasOwnProperty.call(t,o)&&!(o==="sharePages"||o==="sharedLibIgnore")&&o!=="app"&&!s.has(o))if(a(t[o])&&a(n[o]))if(o==="designSystem")d(n[o],t[o],s,o);else for(const i in t[o])s.has(`${o}/${i}`)||(i in n[o]?b(o,n[o][i])&&!b(o,t[o][i])&&(n[o][i]=t[o][i]):n[o][i]=t[o][i]);else o in n||(n[o]=h(t[o],s,o))},N=(n,t)=>{if(!t||!t.length)return;const r=R(n.designSystem);for(let e=0;e<t.length;e++){let s=t[e],o=j;k(s)&&(o=g(s.ignoreList),s=s.library),a(s)&&P(n,s,o)}r.size&&U(n.designSystem,r)};async function D(n,t={}){if((t.provider||"kv")==="api")return L(n,t);const e=await T(n,t);return e||L(n,t)}async function T(n,t={}){const r=t.kvBaseUrl||v,e=t.env||"production",s=`${r}/kv/${encodeURIComponent(n)}?env=${e}`;try{const o=await fetch(s,{method:"GET"});return o.ok&&(await o.json())?.value||null}catch{return null}}async function L(n,t={}){const r=t.apiBaseUrl||O,{key:e}=f(n);try{const s=`${r}/core/projects/libraries/available?search=${encodeURIComponent(e)}&limit=10`,o=await fetch(s,{method:"GET"});if(!o.ok)return null;const i=await o.json(),l=(i?.items||i?.data||(Array.isArray(i)?i:[])).find(I=>{const{key:_}=f(I?.key);return _.toLowerCase()===e.toLowerCase()});if(!l?.id&&!l?._id)return null;const A=l.id||l._id,S=`${r}/core/projects/${encodeURIComponent(A)}/data?branch=main`,u=await fetch(S,{method:"GET"});if(!u.ok)return null;const p=await u.json();return p?.data||p||null}catch{return null}}async function $(n,t={}){if(a(n))return n;if(y(n)){const{full:r}=f(n);if(!r)return null;try{const e=await D(r,t);return e||console.warn(`[smbls] Shared library "${r}" not found`),e}catch(e){return console.warn(`[smbls] Failed to fetch shared library "${r}":`,e.message),null}}return null}async function z(n,t={}){return!n||!n.length?[]:(await Promise.all(n.map(async e=>{if(k(e)){const s=await $(B(e),t);return s?{library:s,ignoreList:e.ignoreList}:null}return $(e,t)}))).filter(Boolean)}export{d as deepDefaults,D as fetchLibraryData,k as isWrappedLibrary,N as mergeSharedLibraries,g as normalizeIgnoreList,f as normalizeLibraryKey,z as resolveSharedLibraries,G as sharedLibrary};
+import{isObject as l,isString as u}from"./types.js";import{isProtectedElementMethod as d}from"./keys.js";import{isLoudDevRuntime as O}from"./env.js";const w="system",B="https://smbls-kv.nika-980.workers.dev",E="https://api.symbols.app";function h(n){const t=String(n||"").trim();if(!t)return{owner:w,key:"",full:""};let o=null,e=t;if(t.includes("/")){const r=t.indexOf("/");o=t.slice(0,r),e=t.slice(r+1)}e=e.replace(/\.symbo\.ls$/iu,""),o||(o=w);const s=e?`${o}/${e}`:"";return{owner:o,key:e,full:s}}const b=(n,t,o,e)=>{for(const s in t){const r=e?`${e}/${s}`:s;o&&o.has(r)||(s in n?l(n[s])&&l(t[s])&&b(n[s],t[s],o,r):n[s]=t[s])}},g=(n,t,o)=>{if(!l(n)||!t.size)return n;const e=`${o}/`;let s=!1;for(const a of t)if(a.startsWith(e)){s=!0;break}if(!s)return n;const r={};for(const a in n){if(!Object.prototype.hasOwnProperty.call(n,a))continue;const i=`${o}/${a}`;t.has(i)||(r[a]=g(n[a],t,i))}return r},F=new Set,U=new Set(["components","pages","functions","snippets","methods"]),k=(n,t)=>t===""&&U.has(n),$=["fontFamily","fontfamily","font_family","FONT_FAMILY"],P=n=>{const t=new Map;if(!l(n))return t;for(const o of $){const e=n[o];if(l(e))for(const s in e)!l(e[s])||!e[s].isDefault||(t.has(o)||t.set(o,new Set),t.get(o).add(s))}return t},M=(n,t)=>{for(const o of $){const e=n[o];if(!l(e))continue;const s=t.get(o);let r=null;for(const a in e){const i=e[a];if(!l(i)||!i.isDefault||s&&s.has(a))continue;const c={...i};delete c.isDefault,r||(r={...e}),r[a]=c}r&&(n[o]=r)}},D=n=>n.replace(/\.js$/iu,""),L=n=>{const t=new Set;if(!Array.isArray(n))return t;for(const o of n){if(!u(o))continue;const e=o.split("/").map(s=>D(s.trim())).filter(Boolean).join("/");e&&t.add(e)}return t},x=(n,t={})=>({library:n,ignoreList:Array.isArray(t.ignoreList)?t.ignoreList:[]}),A=n=>l(n)&&Array.isArray(n.ignoreList)&&("library"in n||"key"in n||"name"in n),S=n=>n.library!==void 0?n.library:n.key??n.name,m=new Set,V=()=>{m.clear()},T=(n,t)=>{const o=t.filter(e=>!m.has(e));if(o.length){for(const e of o)m.add(e);O()&&console.warn(`[smbls] shared library "${n}" ships ${o.map(e=>`methods.${e}`).join(", ")} \u2014 named like a built-in element method. Refused: the built-in wins; a library cannot replace an element method on the consuming app. If the app wants this version, declare it in the app's OWN methods.`)}},C=(n,t,o)=>{let e=null;for(const s in n)if(d(s)&&(t.has(`methods/${s}`)||o.push(s),!e)){e={};for(const r in n)d(r)||(e[r]=n[r])}return e||n},N=(n,t,o,e="library")=>{const s=L(t.sharedLibIgnore);t.sharePages===!1&&s.add("pages");const r=s.size?new Set([...o,...s]):o,a=[];for(const i in t)if(Object.prototype.hasOwnProperty.call(t,i)&&!(i==="sharePages"||i==="sharedLibIgnore")&&i!=="app"&&!r.has(i)){if(l(t[i])&&l(n[i])){if(i==="designSystem")b(n[i],t[i],r,i);else for(const c in t[i])if(!r.has(`${i}/${c}`)){if(i==="methods"&&d(c)){c in n[i]||a.push(c);continue}c in n[i]?k(i,n[i][c])&&!k(i,t[i][c])&&(n[i][c]=t[i][c]):n[i][c]=t[i][c]}}else if(!(i in n)){const c=t[i],f=i==="methods"&&c&&typeof c=="object"?C(c,r,a):c;n[i]=g(f,r,i)}}a.length&&T(e,a)},G=(n,t,o)=>{if(n!==t){const e=S(n);if(u(e)&&e)return e;if(n.key||n.name)return n.key||n.name}return t&&(t.key||t.name)||`sharedLibraries[${o}]`},q=(n,t)=>{if(!t||!t.length)return;const o=P(n.designSystem);for(let e=0;e<t.length;e++){const s=t[e];let r=s,a=F;A(r)&&(a=L(r.ignoreList),r=r.library),l(r)&&N(n,r,a,G(s,r,e))}o.size&&M(n.designSystem,o)};async function W(n,t={}){if((t.provider||"kv")==="api")return _(n,t);const e=await z(n,t);return e||_(n,t)}async function z(n,t={}){const o=t.kvBaseUrl||B,e=t.env||"production",s=`${o}/kv/${encodeURIComponent(n)}?env=${e}`;try{const r=await fetch(s,{method:"GET"});return r.ok&&(await r.json())?.value||null}catch{return null}}async function _(n,t={}){const o=t.apiBaseUrl||E,{key:e}=h(n);try{const s=`${o}/core/projects/libraries/available?search=${encodeURIComponent(e)}&limit=10`,r=await fetch(s,{method:"GET"});if(!r.ok)return null;const a=await r.json(),c=(a?.items||a?.data||(Array.isArray(a)?a:[])).find(j=>{const{key:R}=h(j?.key);return R.toLowerCase()===e.toLowerCase()});if(!c?.id&&!c?._id)return null;const f=c.id||c._id,I=`${o}/core/projects/${encodeURIComponent(f)}/data?branch=main`,p=await fetch(I,{method:"GET"});if(!p.ok)return null;const y=await p.json();return y?.data||y||null}catch{return null}}async function v(n,t={}){if(l(n))return n;if(u(n)){const{full:o}=h(n);if(!o)return null;try{const e=await W(o,t);return e||console.warn(`[smbls] Shared library "${o}" not found`),e}catch(e){return console.warn(`[smbls] Failed to fetch shared library "${o}":`,e.message),null}}return null}async function H(n,t={}){return!n||!n.length?[]:(await Promise.all(n.map(async e=>{if(A(e)){const s=await v(S(e),t);return s?{library:s,ignoreList:e.ignoreList}:null}return v(e,t)}))).filter(Boolean)}export{V as __resetBuiltinMethodWarnings,b as deepDefaults,W as fetchLibraryData,A as isWrappedLibrary,q as mergeSharedLibraries,L as normalizeIgnoreList,h as normalizeLibraryKey,H as resolveSharedLibraries,x as sharedLibrary};

package/dist/esm/string.js

@@ -1,3 +1,3 @@
-const N=(e,r)=>{for(const t of r)if(e.includes(t))return!0;return!1},O=(e,r)=>{const t=new RegExp(`[${r.join("\\")}]`,"g");return e.replace(t,"")},L={2:/{{\s*((?:\.\.\/)*)([\w\d.]+)\s*(?:\|\s*([\w\d.]+))?\s*}}/g,3:/{{{(\s*(?:\.\.\/)*)([\w\d.]+)\s*(?:\|\s*([\w\d.]+))?\s*}}}/g},x=(e,r)=>r.split(".").reduce((t,a)=>t?.[a],e);function I(e,r,t={}){const{bracketsLength:a=2}=t,f=a===3?"{{{":"{{";if(!e.includes(f))return e;const m=L[a],c=r||this.state||{},i=this;return e.replace(m,(u,d,n,l)=>{const g=n.trim();if(l){const s=i?.context,o=s?.functions?.[l]||s?.utils?.[l]||s?.methods?.[l]||s?.snippets?.[l]||i?.[l];if(o&&typeof o=="function")try{return String(o.call(i,g)??"")}catch{return""}return""}if(d){const s=(d.match(/\.\.\//g)||[]).length;let o=c;for(let p=0;p<s;p++){if(!o||!o.parent)return"";o=o.parent}if(g==="parent")return String(o.value??"");const h=x(o,g);return h!=null&&typeof h=="object"?"":String(h??"")}else{const s=x(c,g);if(s!=null&&typeof s!="object")return String(s);const o=i?.context?.polyglot;if(o?.translations){const h=c?.root?.lang||c?.lang||i?.context?.state?.lang||o.defaultLang||"en",p=o.translations[h];if(p){const C=x(p,g);if(C!=null&&typeof C!="object")return String(C);for(const w in p){const b=p[w];if(b&&typeof b=="object"&&!Array.isArray(b)){const S=x(b,g);if(S!=null&&typeof S!="object")return String(S)}}}const y=x(o.translations,g);if(y!=null&&typeof y!="object")return String(y)}return""}})}const R=e=>`${e.charAt(0).toLowerCase()}${e.slice(1)}`,k=(e,r)=>{const t=e.split(`
-`);let a=-1,f=-1,m=-1,c=-1;const i=new RegExp(`\\b${r}\\b\\s*:\\s*`);let u=0,d=!1;for(let n=0;n<t.length;n++)if(i.test(t[n])&&!d){if(d=!0,a=n+1,m=t[n].indexOf(r)+1,t[n].includes("{}")){f=a,c=t[n].indexOf("{}")+3;break}const l=t[n].slice(m+r.length);if(l.includes("{")||l.includes("["))u=1;else{f=n+1,c=t[n].length+1;break}}else if(d&&(u+=(t[n].match(/{/g)||[]).length,u+=(t[n].match(/\[/g)||[]).length,u-=(t[n].match(/}/g)||[]).length,u-=(t[n].match(/]/g)||[]).length,u===0)){f=n+1,c=t[n].lastIndexOf("}")!==-1?t[n].lastIndexOf("}")+2:t[n].length+1;break}return{startColumn:m,endColumn:c,startLineNumber:a,endLineNumber:f}},j=/\\([0-7]{1,3})/g,E=e=>e.replace(j,(r,t)=>String.fromCharCode(parseInt(t,8))),$=e=>e.replace(/\n/g,"/////n").replace(/`/g,"/////tilde").replace(/\$/g,"/////dlrsgn"),F=e=>e.replace(/\/\/\/\/\/n/g,`
-`).replace(/\/\/\/\/\/tilde/g,"`").replace(/\/\/\/\/\/dlrsgn/g,"$"),A=/[^a-zA-Z0-9\s]/g,_=e=>e.replace(A,r=>"%"+r.charCodeAt(0).toString(16).toUpperCase()),v=e=>e.replace(/%[0-9A-Fa-f]{2}/g,r=>String.fromCharCode(parseInt(r.slice(1),16)));export{v as customDecodeURIComponent,_ as customEncodeURIComponent,F as decodeNewlines,$ as encodeNewlines,k as findKeyPosition,R as lowercaseFirstLetter,I as replaceLiteralsWithObjectFields,E as replaceOctalEscapeSequences,N as stringIncludesAny,O as trimStringFromSymbols};
+const N=(t,r)=>{for(const e of r)if(t.includes(e))return!0;return!1},O=(t,r)=>{const e=new RegExp(`[${r.join("\\")}]`,"g");return t.replace(e,"")},w={2:/{{\s*((?:\.\.\/)*)([\w\d.]+)\s*(?:\|\s*([\w\d.]+))?\s*}}/g,3:/{{{(\s*(?:\.\.\/)*)([\w\d.]+)\s*(?:\|\s*([\w\d.]+))?\s*}}}/g},x=(t,r)=>r.split(".").reduce((e,s)=>e?.[s],t),A=(t,r)=>{if(!t||!t.__ref)return!0;let e=t;for(;e;){if(e.allowRuntimeTemplates===!0)return!0;const s=e.__ref&&e.__ref.__authoredTemplates;if(s&&s.has(r))return!0;e=e.parent}return!1};function R(t,r,e={}){const{bracketsLength:s=2}=e,f=s===3?"{{{":"{{";if(!t.includes(f)||!A(this,t))return t;const m=w[s],l=r||this.state||{},i=this;return t.replace(m,(u,d,n,a)=>{const p=n.trim();if(a){const c=i?.context,o=c?.functions?.[a]||c?.utils?.[a]||c?.methods?.[a]||c?.snippets?.[a]||i?.[a];if(o&&typeof o=="function")try{return String(o.call(i,p)??"")}catch{return""}return""}if(d){const c=(d.match(/\.\.\//g)||[]).length;let o=l;for(let g=0;g<c;g++){if(!o||!o.parent)return"";o=o.parent}if(p==="parent")return String(o.value??"");const h=x(o,p);return h!=null&&typeof h=="object"?"":String(h??"")}else{const c=x(l,p);if(c!=null&&typeof c!="object")return String(c);const o=i?.context?.polyglot;if(o?.translations){const h=l?.root?.lang||l?.lang||i?.context?.state?.lang||o.defaultLang||"en",g=o.translations[h];if(g){const C=x(g,p);if(C!=null&&typeof C!="object")return String(C);for(const _ in g){const b=g[_];if(b&&typeof b=="object"&&!Array.isArray(b)){const S=x(b,p);if(S!=null&&typeof S!="object")return String(S)}}}const y=x(o.translations,p);if(y!=null&&typeof y!="object")return String(y)}return""}})}const I=t=>`${t.charAt(0).toLowerCase()}${t.slice(1)}`,k=(t,r)=>{const e=t.split(`
+`);let s=-1,f=-1,m=-1,l=-1;const i=new RegExp(`\\b${r}\\b\\s*:\\s*`);let u=0,d=!1;for(let n=0;n<e.length;n++)if(i.test(e[n])&&!d){if(d=!0,s=n+1,m=e[n].indexOf(r)+1,e[n].includes("{}")){f=s,l=e[n].indexOf("{}")+3;break}const a=e[n].slice(m+r.length);if(a.includes("{")||a.includes("["))u=1;else{f=n+1,l=e[n].length+1;break}}else if(d&&(u+=(e[n].match(/{/g)||[]).length,u+=(e[n].match(/\[/g)||[]).length,u-=(e[n].match(/}/g)||[]).length,u-=(e[n].match(/]/g)||[]).length,u===0)){f=n+1,l=e[n].lastIndexOf("}")!==-1?e[n].lastIndexOf("}")+2:e[n].length+1;break}return{startColumn:m,endColumn:l,startLineNumber:s,endLineNumber:f}},L=/\\([0-7]{1,3})/g,E=t=>t.replace(L,(r,e)=>String.fromCharCode(parseInt(e,8))),$=t=>t.replace(/\n/g,"/////n").replace(/`/g,"/////tilde").replace(/\$/g,"/////dlrsgn"),F=t=>t.replace(/\/\/\/\/\/n/g,`
+`).replace(/\/\/\/\/\/tilde/g,"`").replace(/\/\/\/\/\/dlrsgn/g,"$"),j=/[^a-zA-Z0-9\s]/g,T=t=>t.replace(j,r=>"%"+r.charCodeAt(0).toString(16).toUpperCase()),v=t=>t.replace(/%[0-9A-Fa-f]{2}/g,r=>String.fromCharCode(parseInt(r.slice(1),16)));export{v as customDecodeURIComponent,T as customEncodeURIComponent,F as decodeNewlines,$ as encodeNewlines,k as findKeyPosition,I as lowercaseFirstLetter,R as replaceLiteralsWithObjectFields,E as replaceOctalEscapeSequences,N as stringIncludesAny,O as trimStringFromSymbols};

package/keys.js

@@ -148,6 +148,43 @@ export const METHODS = new Set([
   'preventContentRecreate'
 ])
 
+// Is `name` a built-in element method (or a reserved element key)? Every method
+// on @symbo.ls/element's prototype is in METHODS — locked by
+// element/__tests__/libraryMethodsCannotShadowBuiltins.test.js.
+export const isBuiltinElementMethod = (name) => METHODS.has(name)
+
+// The built-in element methods a SHARED LIBRARY may replace — the OVERRIDE
+// POINTS (FW-LIBRARY-METHODS-CANNOT-SHADOW-BUILTIN-ELEMENT-METHODS-1). They are
+// observability hooks, not element semantics: the element's own tree, state
+// and rendering never depend on what they do, so a library's version cannot
+// break the element the way a stale getRoot / getRootState copy did — and
+// apps link libraries precisely to route these outputs. Every other built-in
+// is protected: a library copy is refused, the built-in wins. The app's OWN
+// methods win over both, as for any method.
+export const ELEMENT_METHOD_OVERRIDE_POINTS = new Set([
+  // Message logging. The built-in is a debug dump — element `log(...keys)`
+  // prints `{ key: el[key] }`; a library's `log(...params)` prints its
+  // messages, which is what its own methods call it for.
+  'log',
+  // Warning channel. The built-in prints only in test/development; a library
+  // routes warnings in every environment (console, telemetry) and continues.
+  'warn',
+  // Error channel. The built-in THROWS in test/development and is silent in
+  // production; a library reports and continues (`return this.error('…')` is
+  // an early exit that must not become an exception), with its own hooks
+  // (`onError`, `verbose`, `debugger` options).
+  'error',
+  // Debug inspector for an element — a development aid a library may style
+  // or redirect.
+  'verbose'
+])
+
+// A built-in element method that a library can NOT replace: METHODS minus the
+// override points. The single test the shared-library merge and the element's
+// fold / `el.call` paths use.
+export const isProtectedElementMethod = (name) =>
+  METHODS.has(name) && !ELEMENT_METHOD_OVERRIDE_POINTS.has(name)
+
 export const METHODS_EXL = new Set([
   'node', 'context', 'extends', '__element', '__ref',
   ...METHODS,

package/methods.js

@@ -3,7 +3,7 @@
 import { triggerEventOn } from './triggerEvent.js'
 import { DOMQ_PROPERTIES, METHODS, PARSED_DOMQ_PROPERTIES } from './keys.js'
 import { isDefined, isFunction, isObject, isObjectLike } from './types.js'
-import { deepClone } from './object.js'
+import { deepClone, isFailedRevival } from './object.js'
 import { isProduction } from './env.js'
 import { removeValueFromArray } from './array.js'
 import { OPTIONS } from './cache.js'
@@ -214,6 +214,25 @@ export const setActiveRootState = (state) => {
   _activeRootState = state || null
 }
 
+/**
+ * `prepareContext` registers the PREPARED root state — a plain object — before
+ * the app root element exists. The root element then builds its OWN reactive
+ * store from that object (@symbo.ls/element createElementState), so the
+ * registered object is only a boot-time copy: it names no element, never sees
+ * a write and has no store methods. Every `getRootState()` fallback read went
+ * stale, and `getRoot()`'s fallback (`getRootState()?.__element`) could never
+ * resolve the app for an element whose `__ref` was cleared by `remove()`
+ * (FW-ROOT-STATE-REGISTERED-AS-A-DETACHED-PLAIN-COPY-1).
+ *
+ * @symbo.ls/element calls this when it builds a store from `source`: if the
+ * registry holds exactly `source`, it now holds the live `store`. Gated on
+ * identity, so an unrelated element tree created later can never take the
+ * registry over.
+ */
+export const promoteActiveRootState = (source, store) => {
+  if (source && store && _activeRootState === source) _activeRootState = store
+}
+
 const readFallbackState = () => {
   // The framework-managed registry (set by prepareContext during
   // create(...)) is the single source of truth for the active root
@@ -472,6 +491,10 @@ export function call (fnKey, ...args) {
     context.snippets?.[fnKey]
   )
   if (!fn) return
+  // A lazily revived function whose source does not compile stands for the
+  // string eager revival left (object.js "LAZY REVIVAL"), which this helper
+  // could not call either: undefined, as before.
+  if (isFailedRevival(fn)) return
   try {
     const result = fn.call(this, ...args)
     if (result && typeof result.then === 'function') {

package/object.js

@@ -387,16 +387,32 @@ const RE_MODULE_PREFIX = /^(export|import)\s/
 export const hasFunction = (str) => {
   if (!str) return false
 
-  const trimmed = str.trim().replace(/\n\s*/g, ' ').trim()
+  // SMBLS-BOOT-LAZY-EVAL-1: this runs on EVERY string of a project context
+  // at boot (Pulse: ~26k strings, 2 MB), so it must reject a non-function
+  // string cheaply. Both steps below are exact — the result is identical to
+  // the previous form (`str.trim().replace(/\n\s*/g, ' ').trim()` then every
+  // pattern), pinned by __tests__/hasFunctionEquivalence.test.js:
+  //   • no newline collapsing: every pattern reads `\s`, `[^)]`, `[^}]`,
+  //     `[^=]` or `[\s\S]` where a newline run and a space both match, and
+  //     nothing else looks at whitespace;
+  //   • the pre-filter: every pattern needs `=>`, or a `function` / `async`
+  //     / `(` prefix, or a `(` plus a closing `}` (method shorthand) — a
+  //     string with none of those can match none of them.
+  const trimmed = str.trim()
 
   if (trimmed === '' || trimmed === '{}' || trimmed === '[]') return false
+  const hasArrow = trimmed.includes('=>')
+  if (!hasArrow &&
+    trimmed.charCodeAt(0) !== 40 && // '(' — `(function …`
+    !trimmed.startsWith('function') &&
+    !trimmed.startsWith('async') &&
+    !(trimmed.charCodeAt(trimmed.length - 1) === 125 && trimmed.includes('('))) return false
   if (RE_MODULE_PREFIX.test(trimmed)) return false
 
   const isFn = FN_PATTERNS.some((pattern) => pattern.test(trimmed))
   if (!isFn) return false
 
   const firstChar = trimmed.charCodeAt(0)
-  const hasArrow = trimmed.includes('=>')
   // '{' = 123, '[' = 91
   if (firstChar === 123 && !hasArrow) return false // object literal
   if (firstChar === 91) return false // array literal
@@ -518,8 +534,12 @@ const stripTopLevelDeclaration = (src, name) => {
 // the structural walker used inline. Returns either the eval'd value or
 // the original string (with a console.warn) so callers can assign the
 // result directly. `label` is used in warning messages so the surface
-// of the failure (object key vs array index) is identifiable.
-const _destringifyFnString = (str, label, opts) => {
+// of the failure (object key vs array index) is identifiable. `lazy` only
+// changes the warning's description of the outcome: a lazily revived
+// function (see LAZY REVIVAL below) compiles on its first use, and when the
+// source does not compile it stands for the string an eager revival leaves
+// in place.
+const _destringifyFnString = (str, label, opts, lazy) => {
   // Module SOURCE files are stored as plain strings on project data
   // (`code` fields driving CodePreview etc. — they start with
   // `export …` / `import …`). They are display text, not function
@@ -594,7 +614,10 @@ const _destringifyFnString = (str, label, opts) => {
     if (typeof console !== 'undefined' && console.warn) {
       console.warn(
         `[smbls] deepDestringifyFunctions: eval failed on ${label} — ` +
-        'value will be left as a string. Reason: ' + msg + '.\n' +
+        (lazy
+          ? 'revived lazily, so its source compiled on this first use; it acts as the string it replaces ' +
+            '(a call returns the source text, el.call treats it as not callable). Reason: '
+          : 'value will be left as a string. Reason: ') + msg + '.\n' +
         'First 200 chars of source: ' + String(str).slice(0, 200)
       )
     }
@@ -602,12 +625,350 @@ const _destringifyFnString = (str, label, opts) => {
   }
 }
 
+// ─────────────────────────────────────────────────────────────────────────
+// LAZY REVIVAL — SMBLS-BOOT-LAZY-EVAL-1
+//
+// Measured on anseta/pulse 1.31.1 (runtime 3.14.808, Lighthouse mobile):
+// the page context carries 3,735 function strings (1.82 MB of source), and
+// the eager walk ran one indirect eval per string before the first render —
+// the largest self time of the whole boot (561 ms unthrottled, ~2.2 s at
+// 4x CPU). A page calls a small share of them: one route's props and a few
+// dozen registered functions.
+//
+// `deepDestringifyFunctions(obj, dest, { lazy: true })` keeps each source
+// and installs a WRAPPER that compiles it on the first call — through the
+// SAME `opts.window.eval` and the SAME recovery passes (`_destringifyFnString`
+// above) the eager walk uses — caches the result and calls straight through
+// from then on. Opt-in: the default stays eager, because tooling reads the
+// eager result (frank's toFS prints a string that failed to compile as a
+// quoted literal, helmet tests for "still a string", the workspace re-realm
+// pass reads `Function.prototype.toString`). The runtime boot paths opt in:
+// the published/runner page scripts and prepareContext's rehydrate.
+//
+// What a wrapper preserves (each pinned in __tests__/deepDestringifyLazy.test.js):
+//   • identity — the wrapper IS the function for its whole life. It never
+//     swaps itself out after compiling, so WeakMap keys, listener dedupe and
+//     `===` stay stable. Two slots with equal source get two wrappers, as
+//     two evals gave two functions.
+//   • `this`, every argument, the return value (an async source still
+//     returns its promise), and `new` for a plain `function` source
+//     (`Reflect.construct` with the wrapper as new.target, so instances are
+//     `instanceof` the wrapper the outside world holds).
+//   • `typeof` 'function', `.call`/`.apply`/`.bind`.
+//   • `.toString()` — the ORIGINAL source (trimmed, as an eval'd function
+//     expression reports it), without compiling. frank, the editor, SSR and
+//     inspectors re-serialize through it.
+//   • `.length` — the compiled function's arity, read through an accessor
+//     that compiles on demand (only the dev-only stashed-callback advisory
+//     in element/create.js and `Function.prototype.bind` read it).
+//   • `.name` — what the eager eval would report: the declared name of a
+//     `function` or method source, '' for an arrow or anonymous function.
+//   • no `.prototype`, not constructible, for arrow / async / method
+//     sources — a method-shorthand wrapper, like the eval'd value; an
+//     async source's wrapper inherits %AsyncFunction.prototype%, so
+//     `instanceof`, `.constructor` and the toStringTag say AsyncFunction.
+//
+// What cannot be preserved: `Function.prototype.toString.call(wrapper)`
+// reads the wrapper's own text, not the stored source — no function object
+// can answer it without compiling. `getFunctionSource(fn)` below answers it
+// for any function; the one in-repo caller (element's dev advisory) uses it.
+// Two more, kept on purpose (PR #187 review N2, N3):
+//   • `.caller` / `.arguments` on the wrapper of a plain `function` source
+//     throw (the wrapper is strict code). A sloppy wrapper would answer them,
+//     but it would also coerce `this` (undefined → globalThis, primitives →
+//     objects) before a strict source sees it; `this` is the contract.
+//   • every call runs one extra frame, so the deepest recursion through a
+//     registry reference roughly halves (probe: 8,959 → 4,607 frames).
+//     Swapping the slot to the compiled function after the first call would
+//     remove the frame but split identity (a listener added with the wrapper
+//     could no longer be removed with the slot's value).
+//
+// Only an UNAMBIGUOUS function expression is revived lazily (see
+// `lazyStateFor`): an arrow, a plain/async `function`, or a method
+// shorthand, whose head the regexes below prove. Everything else `hasFunction`
+// accepts — prose that starts with "function", a generator (its `.prototype`
+// is a generator prototype), a named function that refers to itself by name
+// (its self-binding would be the compiled function, not the wrapper), a
+// `(function…)` wrapped form — keeps the eager path exactly as before, string
+// fallback and boot-time warning included.
+//
+// A lazily revived source that fails to compile warns with today's
+// diagnostic (prefix, reason, first 200 chars) on its FIRST USE instead of
+// at boot, and from then on stands for the STRING eager revival leaves in
+// place (PR #187 review S4): every call returns that string, so a prop DOMQL
+// evaluates by calling it (`text`, `if`, `hide`, attributes, CSS, custom
+// props, `state`) gets exactly the value the string gave — a broken `if`
+// stays truthy, prose in `text` still shows — and `el.call` / utils `call`
+// ask `isFailedRevival` first and treat it as not callable, exactly as they
+// treated the string (undefined, and el.call's "resolves to a non-function
+// (string)" error). What remains different: `typeof` is 'function', and a
+// DIRECT call from other code returns the string where calling a string
+// threw a TypeError.
+//
+// `{ lazy: 'context' }` is the page scripts' mode for a whole project
+// context: only the CODE buckets (LAZY_CONTEXT_CODE_KEYS) revive lazily;
+// data — state, designSystem, polyglot, files, schema, config values —
+// keeps eager revival, so a function-looking data string that does not
+// compile stays the string it is, for code that READS it as a value.
+// `{ lazy: true }` is lazy everywhere: the bucket-level callers
+// (prepareContext's rehydrate of components, pages, functions, …).
+//
+// Identical sources are NOT shared. It would be safe — the compiled
+// function never leaves its wrapper, and the self-referencing shapes that
+// could observe it keep the eager path — but it does not pay: of the 388
+// compiles the first render of Pulse /home triggers, 82 repeat a source
+// (~6 ms of eval), against a per-realm cache every wrapper would consult.
+// ─────────────────────────────────────────────────────────────────────────
+
+const LAZY_KIND_PLAIN = 1 // `function` — constructible, has its own `.prototype`
+const LAZY_KIND_CALLABLE = 2 // arrow / async function / method — neither
+
+// wrapper → { src, name, kind, async, fn, value, key, index, opts }
+// `fn` is undefined until the first compile, then the compiled function, or
+// null when the source did not compile to one — `value` is then what eager
+// revival leaves in the slot (the source string).
+const LAZY_FN_STATE = new WeakMap()
+
+// Every head below must PROVE its shape up to the body's opening brace or the
+// arrow. Parameters are accepted without strings, template literals or slashes
+// (comments, regex literals, division) and with at most one level of nested
+// parens; a head these cannot prove falls back to the eager path — it is
+// never misread.
+const RE_LAZY_FUNCTION_HEAD = /^(async\s+)?function(?![\w$])\s*(\*)?\s*([A-Za-z_$][\w$]*)?\s*\((?:[^()'"`/]|\([^()'"`/]*\))*\)\s*\{/
+const RE_LAZY_ARROW_IDENT_HEAD = /^(async\s+)?[A-Za-z_$][\w$]*\s*=>/
+const RE_LAZY_ARROW_PARENS_HEAD = /^(async\s*)?\((?:[^()'"`/]|\([^()'"`/]*\))*\)\s*=>/
+const RE_LAZY_METHOD_HEAD = /^(async\s+)?([A-Za-z_$][\w$]*)\s*\((?:[^()'"`/]|\([^()'"`/]*\))*\)\s*\{/
+
+// A method-shorthand head named like a keyword is prose or a statement
+// (`if (x) { … }`, `for (…) { … }`), never a revivable method.
+const LAZY_NON_METHOD_NAMES = new Set([
+  'if', 'for', 'while', 'switch', 'catch', 'with', 'do', 'return', 'typeof',
+  'void', 'delete', 'new', 'in', 'of', 'instanceof', 'function', 'class',
+  'const', 'let', 'var', 'await', 'yield', 'import', 'export', 'try', 'else',
+  'throw', 'case', 'default', 'break', 'continue', 'debugger', 'finally',
+  'super', 'this', 'null', 'true', 'false', 'async', 'get', 'set', 'static'
+])
+
+const _isIdentCharCode = (c) =>
+  (c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || c === 36 || c === 95
+
+// `name` appears in `src` at or after `from` as a whole identifier token.
+// Conservative on purpose (a property named like the function also counts):
+// a false hit only means the eager path.
+const _mentionsIdentifier = (src, name, from) => {
+  let i = src.indexOf(name, from)
+  while (i !== -1) {
+    const end = i + name.length
+    if ((i === 0 || !_isIdentCharCode(src.charCodeAt(i - 1))) &&
+      (end >= src.length || !_isIdentCharCode(src.charCodeAt(end)))) return true
+    i = src.indexOf(name, end)
+  }
+  return false
+}
+
+const _lastNonSpaceCharCode = (s) => {
+  let i = s.length - 1
+  while (i >= 0 && s.charCodeAt(i) <= 32) i--
+  return i < 0 ? -1 : s.charCodeAt(i)
+}
+
+// Classify one source string for lazy revival: a fresh state object, or null
+// when the eager path must revive it (see the header above for each case).
+const lazyStateFor = (src) => {
+  let s = src
+  let start = 0
+  while (start < s.length && s.charCodeAt(start) <= 32) start++
+  if (start) s = s.slice(start)
+
+  let m = RE_LAZY_FUNCTION_HEAD.exec(s)
+  if (m) {
+    if (m[2]) return null // generator
+    if (_lastNonSpaceCharCode(s) !== 125) return null // must end with its body's `}`
+    const name = m[3] || ''
+    if (name && _mentionsIdentifier(s, name, m[0].indexOf('('))) return null // self-reference (params or body)
+    if (s.indexOf('arguments.callee') !== -1) return null
+    return { src, name, kind: m[1] ? LAZY_KIND_CALLABLE : LAZY_KIND_PLAIN, async: !!m[1], fn: undefined }
+  }
+  m = RE_LAZY_ARROW_IDENT_HEAD.exec(s) || RE_LAZY_ARROW_PARENS_HEAD.exec(s)
+  if (m) {
+    return { src, name: '', kind: LAZY_KIND_CALLABLE, async: !!m[1], fn: undefined }
+  }
+  m = RE_LAZY_METHOD_HEAD.exec(s)
+  if (m && !LAZY_NON_METHOD_NAMES.has(m[2]) && _lastNonSpaceCharCode(s) === 125) {
+    if (s.indexOf('arguments.callee') !== -1) return null
+    return { src, name: m[2], kind: LAZY_KIND_CALLABLE, async: !!m[1], fn: undefined }
+  }
+  return null
+}
+
+const _lazyLabel = (state) => state.index === -1
+  ? `"${state.key}"`
+  : `array index ${state.index} (prop "${state.key}")`
+
+const compileLazy = (state) => {
+  const out = _destringifyFnString(state.src, _lazyLabel(state), state.opts, true)
+  let fn = null
+  if (typeof out === 'function') {
+    fn = out
+  } else {
+    // Not a function: the value eager revival leaves in the slot — the
+    // source string when it did not compile (`_destringifyFnString` has
+    // warned), or, unreachable for a head the regexes proved, whatever the
+    // expression evaluated to. The wrapper stands for it from now on.
+    state.value = out
+    if (typeof out !== 'string' && typeof console !== 'undefined' && console.warn) {
+      console.warn(
+        `[smbls] deepDestringifyFunctions: ${_lazyLabel(state)} did not evaluate to a function — ` +
+        'the lazily revived function returns that value.\n' +
+        'First 200 chars of source: ' + String(state.src).slice(0, 200)
+      )
+    }
+  }
+  state.fn = fn
+  state.opts = null // the eval handle is no longer needed
+  return fn
+}
+
+// Kept out of the wrappers' own text so `Function.prototype.toString.call`
+// on a wrapper names no global at all (the workspace re-realm gate reads it).
+const _constructLazy = (fn, args, newTarget) => Reflect.construct(fn, args, newTarget)
+
+function lazyFunctionToString () {
+  const state = LAZY_FN_STATE.get(this)
+  return state ? state.src.trim() : Function.prototype.toString.call(this)
+}
+
+// Shared by every wrapper — one defineProperties call, no per-wrapper
+// descriptor objects.
+const LAZY_FN_DESCRIPTORS = {
+  length: {
+    get () {
+      const state = LAZY_FN_STATE.get(this)
+      if (!state) return 0
+      const fn = state.fn === undefined ? compileLazy(state) : state.fn
+      return fn ? fn.length : 0
+    },
+    configurable: true
+  },
+  name: {
+    get () {
+      const state = LAZY_FN_STATE.get(this)
+      return state ? state.name : ''
+    },
+    configurable: true
+  },
+  toString: { value: lazyFunctionToString, writable: true, configurable: true }
+}
+
+// An async source's wrapper inherits from %AsyncFunction.prototype% (review
+// N1): `Object.prototype.toString` reports '[object AsyncFunction]',
+// `.constructor` is AsyncFunction and `instanceof` holds — while the wrapper
+// itself stays a plain synchronous call that hands back the inner promise
+// (an `async` wrapper would add microtask ticks to every call).
+const ASYNC_FUNCTION_PROTOTYPE = Object.getPrototypeOf(async function () {})
+
+const makeLazyFunction = (state) => {
+  let wrapper
+  if (state.kind === LAZY_KIND_PLAIN) {
+    wrapper = function () {
+      const fn = state.fn === undefined ? compileLazy(state) : state.fn
+      if (fn === null) return state.value
+      return new.target
+        ? _constructLazy(fn, arguments, new.target)
+        : fn.apply(this, arguments)
+    }
+  } else {
+    // A method shorthand: receives `this`, has no `.prototype`, and throws
+    // on `new` — the same as the arrow / async / method it stands for.
+    wrapper = ({
+      lazy () {
+        const fn = state.fn === undefined ? compileLazy(state) : state.fn
+        if (fn === null) return state.value
+        return fn.apply(this, arguments)
+      }
+    }).lazy
+  }
+  LAZY_FN_STATE.set(wrapper, state)
+  Object.defineProperties(wrapper, LAZY_FN_DESCRIPTORS)
+  if (state.async) Object.setPrototypeOf(wrapper, ASYNC_FUNCTION_PROTOTYPE)
+  return wrapper
+}
+
+// Revive one function string lazily when its head allows, eagerly otherwise.
+const _reviveLazily = (str, key, index, opts) => {
+  const state = lazyStateFor(str)
+  if (!state) {
+    return _destringifyFnString(
+      str,
+      index === -1 ? `"${key}"` : `array index ${index} (prop "${key}")`,
+      opts
+    )
+  }
+  state.key = key
+  state.index = index
+  state.opts = opts
+  return makeLazyFunction(state)
+}
+
+/**
+ * True for a function `deepDestringifyFunctions(…, { lazy: true })` revived
+ * lazily (compiled or not yet).
+ */
+export const isLazyFunction = (fn) => typeof fn === 'function' && LAZY_FN_STATE.has(fn)
+
+/**
+ * The source text of any function: the stored source of a lazily revived
+ * one (without compiling it), `Function.prototype.toString` for the rest.
+ * Use this instead of `Function.prototype.toString.call(fn)`, which reads a
+ * lazy wrapper's own text.
+ */
+export const getFunctionSource = (fn) => {
+  const state = LAZY_FN_STATE.get(fn)
+  return state ? state.src.trim() : Function.prototype.toString.call(fn)
+}
+
+/**
+ * True when `fn` is a lazily revived function whose source does not compile
+ * — it stands for the string eager revival would have left, so a caller that
+ * treated that string as "not callable" (`el.call`, utils `call`) must treat
+ * `fn` the same. Compiles `fn` if it has not run yet (the caller was about to
+ * call it). False for every other value.
+ */
+export const isFailedRevival = (fn) => {
+  const state = typeof fn === 'function' ? LAZY_FN_STATE.get(fn) : undefined
+  if (!state) return false
+  return (state.fn === undefined ? compileLazy(state) : state.fn) === null
+}
+
+// The CODE buckets of a project context — `{ lazy: 'context' }` revives
+// lazily only under these top-level keys (see LAZY REVIVAL above).
+const LAZY_CONTEXT_CODE_KEYS = new Set([
+  'components', 'pages', 'functions', 'methods', 'snippets', 'app', 'globalScope'
+])
+
+const DEFAULT_DESTRINGIFY_OPTS = { window: { eval: __globalEval } }
+
 export const deepDestringifyFunctions = (
   obj,
   destringified = {},
-  opts = { window: { eval: __globalEval } }
+  opts = DEFAULT_DESTRINGIFY_OPTS
 ) => {
   if (!obj || typeof obj !== 'object') return destringified
+  // `opts.window.eval` is the one field every runtime since 2026-04 reads,
+  // so a page script can pass `{ lazy: true, window }` to ANY runtime: an
+  // older one ignores `lazy` and evals eagerly through `window.eval` (an
+  // indirect, global-scope eval — the same as `__globalEval`). An options
+  // object without a usable `window.eval` falls back to the global eval
+  // instead of throwing on the first function string.
+  if (!opts || !opts.window || typeof opts.window.eval !== 'function') {
+    opts = { ...opts, window: { eval: __globalEval } }
+  }
+  // `lazy: true` — lazy everywhere. `lazy: 'context'` — `obj` is a project
+  // context: lazy only below its code buckets, eager for everything else.
+  const lazyAll = opts.lazy === true
+  const lazyContext = opts.lazy === 'context'
+  const lazyBelow = (src, prop, lazyHere) => lazyAll ||
+    (lazyContext && (src === obj ? LAZY_CONTEXT_CODE_KEYS.has(prop) : lazyHere))
 
   // Iterative walk with explicit stack so deeply-nested project data
   // (a frank-readback of a complex DOMQL tree, for instance) doesn't
@@ -615,25 +976,30 @@ export const deepDestringifyFunctions = (
   // form did. Stack frame: [src, dest] where dest is the container
   // results land in. Array items handled in-place; nested objects /
   // arrays get a fresh child container pushed onto the stack.
-  const stack = [[obj, destringified]]
+  const stack = [[obj, destringified, lazyAll]]
   while (stack.length) {
-    const [src, dest] = stack.pop()
+    const [src, dest, lazyHere] = stack.pop()
     for (const prop in src) {
       if (!Object.prototype.hasOwnProperty.call(src, prop)) continue
       const objProp = src[prop]
       if (isString(objProp)) {
         if (hasFunction(objProp)) {
-          dest[prop] = _destringifyFnString(objProp, `"${prop}"`, opts)
+          dest[prop] = lazyHere
+            ? _reviveLazily(objProp, prop, -1, opts)
+            : _destringifyFnString(objProp, `"${prop}"`, opts)
         } else {
           dest[prop] = objProp
         }
       } else if (isArray(objProp)) {
         const arr = (dest[prop] = [])
+        const lazyItems = lazyBelow(src, prop, lazyHere)
         for (let i = 0; i < objProp.length; i++) {
           const arrProp = objProp[i]
           if (isString(arrProp)) {
             arr.push(hasFunction(arrProp)
-              ? _destringifyFnString(arrProp, `array index ${i} (prop "${prop}")`, opts)
+              ? (lazyItems
+                  ? _reviveLazily(arrProp, prop, i, opts)
+                  : _destringifyFnString(arrProp, `array index ${i} (prop "${prop}")`, opts))
               : arrProp)
           } else if (isObject(arrProp)) {
             const tagged = _rehydrateTagged(arrProp)
@@ -642,7 +1008,7 @@ export const deepDestringifyFunctions = (
             } else {
               const child = {}
               arr.push(child)
-              stack.push([arrProp, child])
+              stack.push([arrProp, child, lazyItems])
             }
           } else {
             arr.push(arrProp)
@@ -665,7 +1031,7 @@ export const deepDestringifyFunctions = (
         const child = (dest[prop] && typeof dest[prop] === 'object' && !isArray(dest[prop]))
           ? dest[prop]
           : (dest[prop] = {})
-        stack.push([objProp, child])
+        stack.push([objProp, child, lazyBelow(src, prop, lazyHere)])
       } else {
         dest[prop] = objProp
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbo.ls/utils",
-  "version": "3.14.774",
+  "version": "3.14.776",
   "license": "CC-BY-NC-4.0",
   "type": "module",
   "module": "./dist/esm/index.js",