mnfst 0.5.199-next.2 → 0.5.199-next.4

package/lib/manifest.appwrite.auth.js

@@ -26,13 +26,14 @@ async function ensureManifest() {
         return window.__manifestLoaded;
     }
 
+    if (window.__manifestPromise) {
+        const shared = await window.__manifestPromise.catch(() => null);
+        if (shared) return shared;
+    }
     try {
         const manifestUrl = (document.querySelector('link[rel="manifest"]')?.getAttribute('href')) || '/manifest.json';
-        const response = await fetch(manifestUrl);
-        const manifest = await response.json();
-        // No-loader path: resolve ${VAR} placeholders the dynamic loader would have.
-        window.ManifestDataConfig?.interpolateManifest?.(manifest);
-        return manifest;
+        window.__manifestPromise = fetch(manifestUrl).then(r => r.json()).then(m => { window.ManifestDataConfig?.interpolateManifest?.(m); return m; });
+        return await window.__manifestPromise;
     } catch (error) {
         return null;
     }

package/lib/manifest.appwrite.data.js

@@ -2,7 +2,7 @@
 
 (function () {
 
-const MANIFEST_BUILD_VERSION = '0.5.199-next.2';
+const MANIFEST_BUILD_VERSION = '0.5.199-next.4';
 
 /* Manifest Data Sources - Appwrite Integration */
 

package/lib/manifest.chat.js

@@ -121,10 +121,20 @@
             state.resetQueued = true;
             queueMicrotask(() => { state.resetQueued = false; reset(); });
         };
-        window.addEventListener('manifest:persist:scope', queue);
+        // pending → resolved at boot is not a switch: keep every window, hydrate the ones still loading, write under the real scope
+        window.addEventListener('manifest:persist:scope', (e) => { if (e.detail && e.detail.boot) adoptScope(); else queue(); });
         for (const type of WIPE_EVENTS) window.addEventListener(type, queue);
     }
 
+    function adoptScope() {
+        state.recent = null; state.indexPromise = null; state.indexDirty = false;
+        state.saved.clear(); state.windows.clear();
+        for (const [id, h] of state.handles) {
+            hydrate(id).then(w => { if (w && h.hydrate) h.hydrate(w.messages); }).catch(noop);
+            touch(id);
+        }
+    }
+
     // Drop every in-memory window and the index; the store's scope prefix already
     // covers the records. Handles go idle — the app re-opens for the new scope.
     function reset() {
@@ -143,9 +153,26 @@
         const r = records();
         const ok = rec && typeof rec === 'object' && rec.scope === (r ? r.scope() : '') && Array.isArray(rec.recent);
         state.recent = ok ? rec.recent.filter(id => typeof id === 'string' || typeof id === 'number') : [];
+        pruneIndex();
         return state.recent;
     }
 
+    // Drop index ids that have no record (entries from before slots were earned on first write)
+    function pruneIndex() {
+        const r = records(); const ids = state.recent;
+        if (!r || !ids || !ids.length) return;
+        const gen = state.generation;
+        const asked = ids.slice();   // the live array may be reordered by a promote while the read is in flight
+        r.get(asked.map(id => r.key('chat', id))).then(got => {
+            if (gen !== state.generation || state.recent !== ids || !got) return;
+            const found = new Set(asked.filter((id, i) => !!got[i]));
+            const keep = ids.filter(id => found.has(id) || (state.handles.get(id) && state.handles.get(id).count() > 0));
+            if (keep.length === ids.length) return;
+            ids.length = 0; ids.push(...keep);
+            state.indexDirty = true; state.pending.set(INDEX, Date.now() + WRITE_DEBOUNCE_MS); schedule();
+        }).catch(noop);
+    }
+
     function ensureIndex() {
         if (state.recent) return Promise.resolve(state.recent);
         if (state.indexPromise) return state.indexPromise;
@@ -451,10 +478,15 @@
         function commitParticipants() { state.participants = [..._participants.values()]; rev().n++; }
         function commitTyping() { state.typing = [..._typing.values()]; rev().n++; }
 
-        // server echo reconciles body/media/status onto the local copy
+        // server echo reconciles body/media/status onto the local copy; meta merges so a
+        // re-delivery from another source (no translation, no channel) never drops fields
         function merge(target, incoming) {
             Object.assign(target.body, incoming.body);
-            for (const k of Object.keys(incoming)) if (k !== 'body' && k !== '_seq') target[k] = incoming[k];
+            for (const k of Object.keys(incoming)) {
+                if (k === 'body' || k === '_seq') continue;
+                if (k === 'meta' && target.meta && incoming.meta && typeof incoming.meta === 'object') { Object.assign(target.meta, incoming.meta); continue; }
+                target[k] = incoming[k];
+            }
         }
 
         // own echo beating the ack: claim the pending row by meta.clientId
@@ -584,7 +616,7 @@
             commit(); commitParticipants(); commitTyping();
         }
 
-        if (P() && !isAggregate && opts.persist !== false) detach = P().attach(conversationId, { snapshot, reset, stale: () => state.stale, count: () => _msgs.length });
+        if (P() && !isAggregate && opts.persistWindow !== false) detach = P().attach(conversationId, { snapshot, reset, hydrate: hydrateWindow, stale: () => state.stale, count: () => _msgs.length });
 
         async function open() {
             state.status = 'loading';

package/lib/manifest.components.js

@@ -61,6 +61,7 @@ window.ManifestComponentsRegistry = {
         // manifest on window yet).  This must be async — a synchronous XHR on
         // the main thread is deprecated and was flagged by PageSpeed.
         let manifest = window.__manifestLoaded || this.manifest;
+        if (!manifest && window.__manifestPromise) manifest = await window.__manifestPromise.catch(() => null);
         if (!manifest) {
             try {
                 const manifestUrl = (document.querySelector('link[rel="manifest"]')?.getAttribute('href')) || '/manifest.json';
@@ -72,6 +73,7 @@ window.ManifestComponentsRegistry = {
                     manifest = await res.json();
                     // No-loader path: resolve ${VAR} placeholders the dynamic loader would have.
                     window.ManifestDataConfig?.interpolateManifest?.(manifest);
+                    window.__manifestPromise = Promise.resolve(manifest);   // share with plugins that init after us
                 } else {
                     console.warn('[Manifest] Failed to load manifest.json (HTTP', res.status + ')');
                 }

package/lib/manifest.d.ts

@@ -268,7 +268,7 @@ export type ManifestExport = (opts?: {
     [extra: string]: unknown;
 }) => Promise<unknown>;
 
-/** `$device` from the utilities plugin (enriched by the native plugin when present). */
+/** `$device` from the utilities plugin (enriched by the device plugin when present). */
 export interface ManifestDevice {
     readonly os: string;
     readonly touch: boolean;
@@ -278,18 +278,25 @@ export interface ManifestDevice {
     readonly platform: string;
 }
 
-/** `$share` from the native plugin — native sheet, web share, or clipboard fallback. */
+/** `$share` from the device plugin — native sheet, web share, or clipboard fallback. */
 export type ManifestShare = (opts?: { title?: string; text?: string; url?: string }) =>
     Promise<{ shared: boolean; method: string; cancelled?: boolean }>;
 
-/** `$push` from the native plugin — push/notification permissions and token. */
+/** `$push` from the device plugin — push/notification permissions and token. */
 export interface ManifestPush {
-    request(): Promise<string>;
+    /** Ask for permission, on your schedule (never prompted on load). */
+    request(): Promise<'granted' | 'denied' | 'prompt' | 'unsupported' | string>;
+    /** Register with the platform push service (no-op on the web). */
+    register(): Promise<unknown>;
+    onToken(handler: (token: string) => void): void;
+    onReceive(handler: (notification: unknown) => void): void;
+    onTap(handler: (notification: unknown) => void): void;
     readonly permission: string;
+    readonly token: string | null;
     [extra: string]: unknown;
 }
 
-/** `$secure` from the native plugin — secure key-value storage (native keychain or fallback). */
+/** `$secure` from the device plugin — secure key-value storage (native keychain or fallback). */
 export interface ManifestSecure {
     get(key: string): Promise<string | null>;
     set(key: string, value: string): Promise<void>;
@@ -299,33 +306,36 @@ export interface ManifestSecure {
     use(adapter: unknown): void;
 }
 
-/** `$links` from the native plugin — deep/universal link handling. */
+/** `$links` from the device plugin — deep/universal link handling. */
 export interface ManifestLinks {
-    on(handler: (url: string) => void): void;
+    /** Take over an inbound link: link.url is the full URL, link.path the route it maps to. */
+    on(handler: (link: { url: string; path: string }) => void): void;
     open(url: string): void;
     readonly last: string | null;
 }
 
-/** `$app` from the native plugin — foreground/background state. */
+/** `$app` from the device plugin — foreground/background state. */
 export interface ManifestApp {
     readonly active: boolean;
     onChange(handler: (active: boolean) => void): void;
 }
 
-/** `$haptics` from the native plugin — haptic feedback with web vibration fallback. */
+/** `$haptics` from the device plugin — haptic feedback with web vibration fallback. */
 export interface ManifestHaptics {
-    impact(style?: string): Promise<unknown>;
-    notification(type?: string): Promise<unknown>;
+    impact(style?: 'LIGHT' | 'MEDIUM' | 'HEAVY' | string): Promise<unknown>;
+    notification(type?: 'SUCCESS' | 'WARNING' | 'ERROR' | string): Promise<unknown>;
+    selection(): Promise<unknown>;
+    vibrate(ms?: number): Promise<unknown> | unknown;
     [extra: string]: unknown;
 }
 
-/** `$biometric` from the native plugin. */
+/** `$biometric` from the device plugin. */
 export interface ManifestBiometric {
     available(): Promise<boolean>;
     verify(opts?: Record<string, unknown>): Promise<unknown>;
 }
 
-/** `$camera` from the native plugin. */
+/** `$camera` from the device plugin. */
 export interface ManifestCamera {
     photo(opts?: Record<string, unknown>): Promise<unknown>;
     pick(opts?: Record<string, unknown>): Promise<unknown>;
@@ -465,23 +475,23 @@ declare global {
     const $edit: ManifestEdit;
     /** Text editor (text-edit plugin). */
     const $text: ManifestTextEdit;
-    /** Device/platform info (utilities; enriched by the native plugin). */
+    /** Device/platform info (utilities; enriched by the device plugin). */
     const $device: ManifestDevice;
-    /** Native share (native plugin). */
+    /** Native share (device plugin). */
     const $share: ManifestShare;
-    /** Push permissions (native plugin). */
+    /** Push permissions (device plugin). */
     const $push: ManifestPush;
-    /** Secure storage (native plugin). */
+    /** Secure storage (device plugin). */
     const $secure: ManifestSecure;
-    /** Deep links (native plugin). */
+    /** Deep links (device plugin). */
     const $links: ManifestLinks;
-    /** App foreground state (native plugin). */
+    /** App foreground state (device plugin). */
     const $app: ManifestApp;
-    /** Haptics (native plugin). */
+    /** Haptics (device plugin). */
     const $haptics: ManifestHaptics;
-    /** Biometric auth (native plugin). */
+    /** Biometric auth (device plugin). */
     const $biometric: ManifestBiometric;
-    /** Camera (native plugin). */
+    /** Camera (device plugin). */
     const $camera: ManifestCamera;
 
     /** Window-level Manifest namespace exposed by the loader. */

package/lib/manifest.data.js

@@ -2,7 +2,7 @@
 
 (function () {
 
-const MANIFEST_BUILD_VERSION = '0.5.199-next.2';
+const MANIFEST_BUILD_VERSION = '0.5.199-next.4';
 
 /* Manifest Data Sources - Configuration */
 
@@ -21,12 +21,15 @@ async function ensureManifest() {
         return window.__manifestLoaded;
     }
 
+    // One request per boot, shared with the loader and the other plugins (window.__manifestPromise)
+    if (window.__manifestPromise) {
+        const shared = await window.__manifestPromise.catch(() => null);
+        if (looksComplete(shared)) return shared;
+    }
     try {
         const manifestUrl = (document.querySelector('link[rel="manifest"]')?.getAttribute('href')) || '/manifest.json';
-        const response = await fetch(manifestUrl);
-        const manifest = await response.json();
-        interpolateManifest(manifest);
-        return manifest;
+        window.__manifestPromise = fetch(manifestUrl).then(r => r.json()).then(m => { interpolateManifest(m); return m; });
+        return await window.__manifestPromise;
     } catch (error) {
         console.error('[Manifest Data] Failed to load manifest:', error);
         return null;
@@ -1623,6 +1626,7 @@ window.ManifestDataStore = {
     // Reads `persist` per source and top-level `persistence`; true when anything opted in
     function configure(manifest) {
         state.configured = true;
+        state.manifest = manifest || null;
         state.sources.clear();
         for (const [name, source] of Object.entries(manifest?.data || {})) {
             if (!source || typeof source !== 'object') continue;
@@ -1652,6 +1656,7 @@ window.ManifestDataStore = {
         if (state.enabled || state.disabled) return state.enabled;
         if (typeof indexedDB === 'undefined' || !indexedDB) return false;
         state.enabled = true;
+        watchAuthSettle(state.manifest);
         if (!state.dbName) state.dbName = `manifest:${(typeof location !== 'undefined' && location.origin) || 'null'}`;
         if (!state.frameworkVersion) state.frameworkVersion = buildVersion;
         state.scope = evaluateScope();
@@ -1794,7 +1799,7 @@ window.ManifestDataStore = {
             if (wasPending) onLanded([...state.sources.keys()]);   // rows that landed while pending get written under the real scope
         }
         if (typeof window !== 'undefined') {
-            try { window.dispatchEvent(new CustomEvent('manifest:persist:scope', { detail: { scope: next, previous: prev } })); } catch { /* no-op */ }
+            try { window.dispatchEvent(new CustomEvent('manifest:persist:scope', { detail: { scope: next, previous: prev, boot: wasPending } })); } catch { /* no-op */ }
         }
     }
 

package/lib/manifest.defer.js

@@ -32,7 +32,7 @@ const URGENT_WINDOW_MS = 1500;
 const URGENT_CAP = 8;
 const PREWARM_CAP = (window.ManifestDeferConfig && window.ManifestDeferConfig.prewarmCap) || 48; // warm-but-unopened containers kept live
 const IDLE_BUDGET_MS = 4;
-const SLICE_MAX = 8;
+const SLICE_MAX = 2;          // containers per idle slice: one big menu render is already a long task, so keep slices short
 const warm = new Set();          // prewarmed, never opened by the user
 let lastGestureAt = -Infinity;
 let urgentWindowAt = -Infinity;

package/lib/manifest.device.js

@@ -0,0 +1,491 @@
+/* manifest.device.js — built from scripts/device/ */
+
+(function () {
+
+// Manifest Native — umbrella core: Capacitor detection + $device enrichment.
+// Capacitor injects window.Capacitor (+ window.Capacitor.Plugins.<Name>) in the
+// native container. Every capability degrades to a web equivalent when absent,
+// so this plugin is safe to load on the web build too.
+
+function manifestNativeIsNative() {
+    const cap = window.Capacitor;
+    return !!(cap && (typeof cap.isNativePlatform !== 'function' || cap.isNativePlatform()));
+}
+function manifestNativePlugin(name) {
+    const cap = window.Capacitor;
+    return (cap && cap.Plugins && cap.Plugins[name]) || null;
+}
+function manifestNativePlatform() {
+    const cap = window.Capacitor;
+    if (cap && typeof cap.getPlatform === 'function') { try { return cap.getPlatform(); } catch (e) {} }
+    return manifestNativeIsNative() ? (document.documentElement.getAttribute('data-os') || 'native') : 'web';
+}
+
+// Authoritatively stamp container/platform for $device + CSS variants.
+function manifestNativeStamp() {
+    try {
+        if (!manifestNativeIsNative()) return;
+        const html = document.documentElement;
+        html.setAttribute('data-native', '');
+        const p = manifestNativePlatform();
+        if (p && p !== 'web') html.setAttribute('data-platform', p);
+    } catch (e) {}
+}
+manifestNativeStamp();
+
+// Register capability magics once Alpine is available.
+let manifestNativeInitialized = false;
+function initManifestNative() {
+    // Network runs here (not at load) so the Capacitor Network reading can reach
+    // the $device store, which utilities registers on alpine:init.
+    if (typeof initManifestNativeNetwork === 'function') initManifestNativeNetwork();
+    if (typeof initManifestShare === 'function') initManifestShare();
+    if (typeof initManifestSecure === 'function') initManifestSecure();
+    if (typeof initManifestLinks === 'function') initManifestLinks();
+    if (typeof initManifestPush === 'function') initManifestPush();
+    if (typeof initManifestApp === 'function') initManifestApp();
+    if (typeof initManifestHaptics === 'function') initManifestHaptics();
+    if (typeof initManifestBiometric === 'function') initManifestBiometric();
+    if (typeof initManifestCamera === 'function') initManifestCamera();
+}
+function ensureManifestNativeInitialized() {
+    if (manifestNativeInitialized) return;
+    if (!window.Alpine || typeof window.Alpine.magic !== 'function') return;
+    manifestNativeInitialized = true;
+    initManifestNative();
+}
+window.ensureManifestNativeInitialized = ensureManifestNativeInitialized;
+document.addEventListener('alpine:init', ensureManifestNativeInitialized);
+if (window.Alpine && typeof window.Alpine.magic === 'function') {
+    setTimeout(ensureManifestNativeInitialized, 0);
+} else {
+    const manifestNativeCheck = setInterval(() => {
+        if (window.Alpine && typeof window.Alpine.magic === 'function') {
+            clearInterval(manifestNativeCheck);
+            ensureManifestNativeInitialized();
+        }
+    }, 10);
+    setTimeout(() => clearInterval(manifestNativeCheck), 5000);
+}
+
+
+// $share — native share sheet (Capacitor Share) → Web Share API → clipboard.
+// Resolves to { shared, method: 'native'|'web'|'clipboard'|'none', cancelled? }.
+
+function manifestShareCancelled(e) {
+    return !!(e && (e.code === 'CANCELED' || e.name === 'AbortError' || /cancel|abort/i.test(e.message || '')));
+}
+function manifestShareClipboard(payload) {
+    const text = payload.url || payload.text || payload.title || '';
+    if (text && navigator.clipboard && navigator.clipboard.writeText) {
+        return navigator.clipboard.writeText(text)
+            .then(() => ({ shared: true, method: 'clipboard' }))
+            .catch(() => ({ shared: false, method: 'none' }));
+    }
+    return Promise.resolve({ shared: false, method: 'none' });
+}
+function manifestShareWeb(payload) {
+    if (navigator.share) {
+        return navigator.share({ title: payload.title, text: payload.text, url: payload.url })
+            .then(() => ({ shared: true, method: 'web' }))
+            .catch(e => manifestShareCancelled(e)
+                ? { shared: false, method: 'web', cancelled: true }
+                : manifestShareClipboard(payload));
+    }
+    return manifestShareClipboard(payload);
+}
+function manifestShare(opts) {
+    const payload = opts || {};
+    const Share = manifestNativePlugin('Share');
+    if (Share) {
+        // When the native sheet is present, never fall through to the web sheet
+        // (that would double-prompt); report the native outcome instead.
+        return Share.share({ title: payload.title, text: payload.text, url: payload.url, dialogTitle: payload.dialogTitle })
+            .then(() => ({ shared: true, method: 'native' }))
+            .catch(e => manifestShareCancelled(e)
+                ? { shared: false, method: 'native', cancelled: true }
+                : { shared: false, method: 'native', error: (e && (e.message || e.code)) || 'failed' });
+    }
+    return manifestShareWeb(payload);
+}
+function initManifestShare() {
+    window.Alpine.magic('share', () => manifestShare);
+}
+
+
+// Network — higher-fidelity connectivity via Capacitor Network, feeding $device.
+// On the web the base $device signal already tracks navigator online/offline;
+// this only upgrades fidelity inside the native container.
+
+function manifestNativeApplyOnline(connected) {
+    const online = connected !== false;
+    try {
+        document.documentElement.setAttribute('data-online', online ? 'true' : 'false');
+        if (window.Alpine && typeof window.Alpine.store === 'function') {
+            const store = window.Alpine.store('device');
+            if (store) store.online = online;
+        }
+    } catch (e) {}
+}
+function initManifestNativeNetwork() {
+    const Network = manifestNativePlugin('Network');
+    if (!Network) return;
+    try { Network.getStatus().then(s => manifestNativeApplyOnline(s && s.connected)).catch(() => {}); } catch (e) {}
+    try { Network.addListener('networkStatusChange', s => manifestNativeApplyOnline(s && s.connected)); } catch (e) {}
+}
+
+
+// $secure — Keychain/Keystore-backed key/value storage (native) with a
+// namespaced localStorage fallback on the web. Intended for session tokens etc.
+// Native: install a Capacitor secure-storage plugin registered as
+// window.Capacitor.Plugins.SecureStorage; if its method shape differs from the
+// adapters below, override with $secure.use(adapter). Verify on device.
+// The web fallback is NOT encrypted — it degrades honestly, not securely.
+
+const MANIFEST_SECURE_NS = 'mnfst:';
+
+function manifestSecureWebBackend() {
+    const ls = () => window.localStorage;
+    return {
+        async get(key) { try { return ls().getItem(MANIFEST_SECURE_NS + key); } catch (e) { return null; } },
+        async set(key, value) { try { ls().setItem(MANIFEST_SECURE_NS + key, String(value)); } catch (e) {} },
+        async remove(key) { try { ls().removeItem(MANIFEST_SECURE_NS + key); } catch (e) {} },
+        async keys() {
+            try { return Object.keys(ls()).filter(k => k.indexOf(MANIFEST_SECURE_NS) === 0).map(k => k.slice(MANIFEST_SECURE_NS.length)); }
+            catch (e) { return []; }
+        },
+        async clear() { try { const ks = await this.keys(); ks.forEach(k => ls().removeItem(MANIFEST_SECURE_NS + k)); } catch (e) {} }
+    };
+}
+
+// Adapts the two common Capacitor secure-storage plugin shapes: localStorage-like
+// (getItem/setItem/removeItem) or object-arg (get/set/remove with {key,value}).
+function manifestSecureNativeBackend(plugin) {
+    const itemApi = typeof plugin.getItem === 'function';
+    return {
+        async get(key) {
+            try {
+                if (itemApi) { const v = await plugin.getItem(key); return v == null ? null : v; }
+                const r = await plugin.get({ key }); return r && typeof r.value !== 'undefined' ? r.value : (r == null ? null : r);
+            } catch (e) { return null; }
+        },
+        async set(key, value) {
+            try { if (itemApi) await plugin.setItem(key, String(value)); else await plugin.set({ key, value: String(value) }); } catch (e) {}
+        },
+        async remove(key) {
+            try { if (typeof plugin.removeItem === 'function') await plugin.removeItem(key); else await plugin.remove({ key }); } catch (e) {}
+        },
+        async keys() { try { const r = await plugin.keys(); return Array.isArray(r) ? r : (r && (r.keys || r.value)) || []; } catch (e) { return []; } },
+        async clear() { try { await plugin.clear(); } catch (e) {} }
+    };
+}
+
+let _manifestSecureBackend = null;
+function manifestSecureBackend() {
+    if (_manifestSecureBackend) return _manifestSecureBackend;
+    const plugin = manifestNativePlugin('SecureStorage');
+    _manifestSecureBackend = plugin ? manifestSecureNativeBackend(plugin) : manifestSecureWebBackend();
+    return _manifestSecureBackend;
+}
+
+function initManifestSecure() {
+    window.Alpine.magic('secure', () => ({
+        get: (k) => manifestSecureBackend().get(k),
+        set: (k, v) => manifestSecureBackend().set(k, v),
+        remove: (k) => manifestSecureBackend().remove(k),
+        keys: () => manifestSecureBackend().keys(),
+        clear: () => manifestSecureBackend().clear(),
+        use: (adapter) => { _manifestSecureBackend = adapter; }
+    }));
+}
+
+
+// $links — deep / universal links. Native: Capacitor App fires appUrlOpen (and a
+// cold-start launch URL); Manifest extracts the path and hands off to the router.
+// $links.on(fn) lets the author take over routing (e.g. load data for /order/123).
+// On the web there's no bridge, but $links.open(url) still works for programmatic
+// deep-linking and testing. Couples with lifecycle + push (tap → route).
+
+function manifestLinkPath(url) {
+    const s = String(url);
+    const scheme = (s.match(/^([a-z][a-z0-9+.-]*):/i) || [])[1];
+    if (scheme && scheme.toLowerCase() !== 'http' && scheme.toLowerCase() !== 'https') {
+        // Custom scheme (myapp://order/123): treat host + path as the route.
+        const rest = s.slice(scheme.length + 1).replace(/^\/\//, '');
+        const cut = rest.search(/[?#]/);
+        const pathPart = (cut === -1 ? rest : rest.slice(0, cut)).replace(/^\/+/, '');
+        const tail = cut === -1 ? '' : rest.slice(cut);
+        return '/' + pathPart + tail;
+    }
+    try { const u = new URL(url, window.location.origin); return u.pathname + u.search + u.hash; }
+    catch (e) { return '/'; }
+}
+
+// Faithful SPA navigation: route through the router's own click interceptor.
+function manifestNavigateTo(path) {
+    const nav = window.ManifestRoutingNavigation;
+    if (nav) {
+        const a = document.createElement('a');
+        a.setAttribute('href', path);
+        document.body.appendChild(a);
+        a.click();
+        a.remove();
+    } else {
+        window.location.assign(path);
+    }
+}
+
+let _manifestLinkHandler = null;
+function manifestHandleUrl(url) {
+    const path = manifestLinkPath(url);
+    try { const s = window.Alpine && window.Alpine.store('links'); if (s) s.last = url; } catch (e) {}
+    if (typeof _manifestLinkHandler === 'function') { try { _manifestLinkHandler({ url, path }); } catch (e) {} return; }
+    manifestNavigateTo(path);
+}
+
+function initManifestLinks() {
+    if (!window.Alpine.store('links')) window.Alpine.store('links', { last: null });
+    window.Alpine.magic('links', () => ({
+        on: (fn) => { _manifestLinkHandler = typeof fn === 'function' ? fn : null; },
+        open: (url) => manifestHandleUrl(url),
+        get last() { const s = window.Alpine.store('links'); return s ? s.last : null; }
+    }));
+
+    const App = manifestNativePlugin('App');
+    if (App) {
+        try { App.addListener('appUrlOpen', (data) => { if (data && data.url) manifestHandleUrl(data.url); }); } catch (e) {}
+        try { App.getLaunchUrl().then(r => { if (r && r.url) manifestHandleUrl(r.url); }).catch(() => {}); } catch (e) {}
+    }
+}
+
+
+// $push — push notifications (Capacitor PushNotifications → APNs/FCM), designed as
+// three author-controlled contracts, not display-only:
+//   1. permission timing — $push.request() (never auto-prompts on load)
+//   2. device token      — $push.onToken(fn): token -> your backend
+//   3. tap -> route       — tapped payload's url/route hands off to the router
+//                           ($push.onTap(fn) to override; reuses $links + $app)
+// Web fallback: permission maps to the Notification API; full web push (service
+// worker + VAPID) is out of scope, so register() is a no-op on the web.
+
+let _manifestPushTokenHandlers = [];
+let _manifestPushReceiveHandlers = [];
+let _manifestPushTapHandler = null;
+
+function manifestPushMapPermission(p) {
+    if (p === 'granted' || p === 'denied' || p === 'prompt') return p;
+    if (p === 'default') return 'prompt';
+    return p || 'prompt';
+}
+
+function manifestPushRoutePayload(notification) {
+    const data = (notification && (notification.data || notification)) || {};
+    return data.url || data.route || data.path || null;
+}
+
+function manifestPushHandleTap(notification) {
+    if (typeof _manifestPushTapHandler === 'function') { try { _manifestPushTapHandler(notification); } catch (e) {} return; }
+    const target = manifestPushRoutePayload(notification);
+    if (target && typeof manifestHandleUrl === 'function') manifestHandleUrl(target);
+}
+
+function initManifestPush() {
+    let store = window.Alpine.store('push');
+    if (!store) {
+        store = { permission: 'prompt', token: null };
+        try { store.permission = (typeof Notification !== 'undefined') ? manifestPushMapPermission(Notification.permission) : 'unsupported'; }
+        catch (e) { store.permission = 'unsupported'; }
+        window.Alpine.store('push', store);
+    }
+
+    const Push = manifestNativePlugin('PushNotifications');
+    if (Push) {
+        try { Push.addListener('registration', t => { store.token = t && t.value; _manifestPushTokenHandlers.forEach(fn => { try { fn(store.token); } catch (e) {} }); }); } catch (e) {}
+        try { Push.addListener('pushNotificationReceived', n => { _manifestPushReceiveHandlers.forEach(fn => { try { fn(n); } catch (e) {} }); }); } catch (e) {}
+        try { Push.addListener('pushNotificationActionPerformed', a => manifestPushHandleTap(a && a.notification)); } catch (e) {}
+    }
+
+    window.Alpine.magic('push', () => ({
+        async request() {
+            const P = manifestNativePlugin('PushNotifications');
+            if (P) { try { const r = await P.requestPermissions(); const p = manifestPushMapPermission(r && r.receive); window.Alpine.store('push').permission = p; return p; } catch (e) { return 'denied'; } }
+            if (typeof Notification !== 'undefined' && Notification.requestPermission) { try { const p = manifestPushMapPermission(await Notification.requestPermission()); window.Alpine.store('push').permission = p; return p; } catch (e) { return 'denied'; } }
+            return 'unsupported';
+        },
+        async register() {
+            const P = manifestNativePlugin('PushNotifications');
+            if (P) { try { await P.register(); } catch (e) {} }
+        },
+        onToken(fn) { if (typeof fn === 'function') _manifestPushTokenHandlers.push(fn); },
+        onReceive(fn) { if (typeof fn === 'function') _manifestPushReceiveHandlers.push(fn); },
+        onTap(fn) { _manifestPushTapHandler = typeof fn === 'function' ? fn : null; },
+        get permission() { const s = window.Alpine.store('push'); return s ? s.permission : 'prompt'; },
+        get token() { const s = window.Alpine.store('push'); return s ? s.token : null; }
+    }));
+}
+
+
+// $app — app lifecycle. Native: Capacitor App appStateChange (foreground/background).
+// Web fallback: document visibilitychange + pageshow/pagehide. $app.active is
+// reactive; onChange hooks fire on transition. Push delivers tapped-notification
+// routing around resume, so this pairs with $push + $links.
+
+let _manifestAppChangeHandlers = [];
+
+function manifestAppSetActive(active) {
+    try { const s = window.Alpine && window.Alpine.store('app'); if (s) s.active = !!active; } catch (e) {}
+    _manifestAppChangeHandlers.forEach(fn => { try { fn(!!active); } catch (e) {} });
+}
+
+function initManifestApp() {
+    const visible = (typeof document !== 'undefined') ? document.visibilityState !== 'hidden' : true;
+    if (!window.Alpine.store('app')) window.Alpine.store('app', { active: visible });
+
+    const App = manifestNativePlugin('App');
+    if (App) {
+        try { App.addListener('appStateChange', s => manifestAppSetActive(s && s.isActive)); } catch (e) {}
+    } else if (typeof document !== 'undefined') {
+        document.addEventListener('visibilitychange', () => manifestAppSetActive(document.visibilityState !== 'hidden'));
+        window.addEventListener('pageshow', () => manifestAppSetActive(true));
+        window.addEventListener('pagehide', () => manifestAppSetActive(false));
+    }
+
+    window.Alpine.magic('app', () => ({
+        get active() { const s = window.Alpine.store('app'); return s ? s.active : true; },
+        onChange(fn) { if (typeof fn === 'function') _manifestAppChangeHandlers.push(fn); }
+    }));
+}
+
+
+// $haptics — tactile feedback. Native: Capacitor Haptics. Web fallback:
+// navigator.vibrate (limited; iOS Safari ignores it — fine, it's an enhancement).
+// No-ops silently when unsupported.
+
+function manifestVibrate(pattern) {
+    try { if (navigator.vibrate) return navigator.vibrate(pattern); } catch (e) {}
+    return false;
+}
+
+function initManifestHaptics() {
+    window.Alpine.magic('haptics', () => ({
+        impact(style) {
+            const H = manifestNativePlugin('Haptics');
+            if (H) { try { return H.impact({ style: style || 'MEDIUM' }); } catch (e) {} }
+            manifestVibrate(10); return Promise.resolve();
+        },
+        notification(type) {
+            const H = manifestNativePlugin('Haptics');
+            if (H) { try { return H.notification({ type: type || 'SUCCESS' }); } catch (e) {} }
+            manifestVibrate([10, 40, 10]); return Promise.resolve();
+        },
+        selection() {
+            const H = manifestNativePlugin('Haptics');
+            if (H) { try { return H.selectionChanged(); } catch (e) {} }
+            manifestVibrate(5); return Promise.resolve();
+        },
+        vibrate(ms) {
+            const H = manifestNativePlugin('Haptics');
+            if (H) { try { return H.vibrate({ duration: ms || 300 }); } catch (e) {} }
+            manifestVibrate(ms || 300); return Promise.resolve();
+        }
+    }));
+}
+
+
+// $biometric — Face ID / Touch ID. Native: a Capacitor biometric plugin
+// (BiometricAuth or NativeBiometric; method shapes differ, adapted below). The web
+// has no equivalent one-shot verify (WebAuthn is a separate server ceremony), so
+// available() is false and verify() reports unsupported — a genuine native win.
+
+function manifestBiometricPlugin() {
+    return manifestNativePlugin('BiometricAuth') || manifestNativePlugin('NativeBiometric') || null;
+}
+
+async function manifestBiometricAvailable() {
+    const B = manifestBiometricPlugin();
+    if (!B) return false;
+    try {
+        if (typeof B.checkBiometry === 'function') { const r = await B.checkBiometry(); return !!(r && r.isAvailable); }
+        if (typeof B.isAvailable === 'function') { const r = await B.isAvailable(); return !!(r && r.isAvailable !== false); }
+    } catch (e) {}
+    return false;
+}
+
+async function manifestBiometricVerify(opts) {
+    const o = opts || {};
+    const B = manifestBiometricPlugin();
+    if (!B) return { verified: false, error: 'unsupported' };
+    try {
+        if (typeof B.authenticate === 'function') { await B.authenticate({ reason: o.reason, title: o.title, subtitle: o.subtitle, cancelTitle: o.cancelTitle }); return { verified: true }; }
+        if (typeof B.verifyIdentity === 'function') { await B.verifyIdentity({ reason: o.reason, title: o.title, subtitle: o.subtitle }); return { verified: true }; }
+    } catch (e) { return { verified: false, error: (e && (e.message || e.code)) || 'failed' }; }
+    return { verified: false, error: 'unsupported' };
+}
+
+function initManifestBiometric() {
+    window.Alpine.magic('biometric', () => ({
+        available: () => manifestBiometricAvailable(),
+        verify: (opts) => manifestBiometricVerify(opts)
+    }));
+}
+
+
+// $camera — capture or pick a photo. Native: Capacitor Camera.getPhoto. Web
+// fallback: a file input (with capture hint on mobile) returning a data URL.
+// Resolves { dataUrl?, format?, cancelled?, error? }.
+
+function manifestCameraWeb(opts) {
+    const o = opts || {};
+    return new Promise(resolve => {
+        try {
+            const input = document.createElement('input');
+            input.type = 'file';
+            input.accept = 'image/*';
+            if (o.source !== 'photos') input.setAttribute('capture', 'environment');
+            input.style.position = 'fixed';
+            input.style.left = '-9999px';
+            let settled = false;
+            const done = (result) => {
+                if (settled) return;
+                settled = true;
+                window.removeEventListener('focus', onFocus);
+                input.remove();
+                resolve(result);
+            };
+            // No 'change' fires when the picker is cancelled; detect it on focus return.
+            const onFocus = () => setTimeout(() => { if (!settled && (!input.files || !input.files.length)) done({ cancelled: true }); }, 500);
+            input.addEventListener('change', () => {
+                const file = input.files && input.files[0];
+                if (!file) { done({ cancelled: true }); return; }
+                const reader = new FileReader();
+                reader.onload = () => done({ dataUrl: reader.result, format: (file.type.split('/')[1]) || '' });
+                reader.onerror = () => done({ cancelled: true, error: 'read-failed' });
+                reader.readAsDataURL(file);
+            });
+            window.addEventListener('focus', onFocus);
+            document.body.appendChild(input);
+            input.click();
+        } catch (e) { resolve({ cancelled: true, error: 'unsupported' }); }
+    });
+}
+
+function manifestCameraPhoto(opts) {
+    const o = opts || {};
+    const Cam = manifestNativePlugin('Camera');
+    if (Cam) {
+        return Cam.getPhoto({ resultType: 'dataUrl', source: o.source === 'photos' ? 'PHOTOS' : 'CAMERA', quality: o.quality || 90 })
+            .then(r => ({ dataUrl: r && (r.dataUrl || r.webPath), format: r && r.format }))
+            .catch(e => ({ cancelled: true, error: (e && (e.message || e.code)) || 'cancelled' }));
+    }
+    return manifestCameraWeb(o);
+}
+
+function initManifestCamera() {
+    window.Alpine.magic('camera', () => ({
+        photo: (opts) => manifestCameraPhoto(opts),
+        pick: (opts) => manifestCameraPhoto(Object.assign({}, opts || {}, { source: 'photos' }))
+    }));
+}
+
+
+})();

package/lib/manifest.edit.js

@@ -93,7 +93,7 @@
         if (theme) themeScopes[k] = el;
         if (theme && !caps.size && !lock) return;   // pure theme scope — a cascade target, NOT an editable area (so it doesn't swallow nested areas)
         if (!caps.size && !lock) ['sort', 'text', 'style'].forEach(c => caps.add(c));   // size is opt-in
-        if ((expression || '').trim() && [...editEls].some(e => e._edit && e._edit.key === k)) console.warn('[edit] duplicate x-edit key (deltas will mis-route):', k);
+        if ((expression || '').trim() && [...editEls].some(e => e !== el && e._edit && e._edit.key === k)) console.warn('[edit] duplicate x-edit key (deltas will mis-route):', k);   // re-init of the same element is not a duplicate
         el._edit = { key: k, caps, lock, gated: modifiers.includes('gated'), theme, authoring: modifiers.includes('authoring') };
         el.setAttribute('data-edit-area', '');
         editEls.add(el);
@@ -1231,10 +1231,34 @@
     }
 
     /* ---- Activation: per-area, always-on by default (.gated needs $edit.on()) ---- */
-    let estore;
+    let estore, booted = false, armQueued = false;
     const isActive = (a) => !!a && (!a._edit.gated || (estore && estore.active));
     const anyActive = () => areas().some(isActive);
-    function armAll() { areas().forEach(a => { if (isActive(a) && !a._armed) { lastSnap[key(a)] = snapshot(a, classify(a)); armArea(a); a._armed = true; } }); armThemeControls(); refresh(); }
+    function armAll() { areas().forEach(a => { if (isActive(a) && !a._armed) { lastSnap[key(a)] = snapshot(a, classify(a)); armArea(a); a._armed = true; } }); armThemeControls(); refresh(); booted = true; }
+
+    /* ---- Late regions: arm when Alpine initialises them, release when it destroys them ---- */
+    // Arming ran once at boot, so anything rendered later — x-if, a route change, a lazy
+    // component, x-markdown output — stayed inert. Every one of those paths goes through
+    // Alpine.initTree, so the x-edit directive itself is the hook; no observer needed.
+    // Deferred one microtask so the tree Alpine is walking is complete before baselines
+    // are captured, and batched so a burst of regions costs one pass.
+    function armLater() {
+        if (!booted || armQueued) return;   // the boot pass still owns start-up ordering
+        armQueued = true;
+        queueMicrotask(() => { armQueued = false; armAll(); });
+    }
+    // Runs from Alpine's directive cleanup (x-if/x-for teardown, or its own mutation
+    // observer), so a removed region drops its observers and its registry slot.
+    function releaseEdit(el) {
+        Object.keys(themeScopes).forEach(k => { if (themeScopes[k] === el) delete themeScopes[k]; });
+        cssvarControls.delete(el);
+        if (!editEls.has(el)) return;
+        if (el._armed) { disarmArea(el); el._armed = false; }
+        [el, ...el.querySelectorAll('*')].forEach(n => { if (n._sortObserver) { n._sortObserver.disconnect(); n._sortObserver = null; } });
+        editEls.delete(el); delete el._edit;
+        el.removeAttribute('data-edit-area');
+        refresh();
+    }
     // Build B-side source patches from the edit set (storage-agnostic; overlay
     // already auto-persists to localStorage on commit).
     function buildPatches() {
@@ -1337,7 +1361,11 @@
     function waitForData(area, cb) { const expr = dataSourceExpr(area), tpl = area.querySelector('template[x-for]'); let n = 0; const t = setInterval(() => { let r = false; try { r = Array.isArray(window.Alpine.evaluate(tpl, expr)); } catch {} if (r) { clearInterval(t); cb(); } else if (++n > 100) clearInterval(t); }, 50); }
     function init() {
         if (!window.Alpine || !Alpine.directive) return;
-        Alpine.directive('edit', (el, { modifiers, expression }) => registerEdit(el, modifiers, expression));
+        Alpine.directive('edit', (el, { modifiers, expression }, { cleanup }) => {
+            registerEdit(el, modifiers, expression);
+            armLater();                        // a region rendered after boot arms itself
+            cleanup(() => releaseEdit(el));    // ...and lets go when Alpine tears it down
+        });
         Alpine.store('edit', {
             active: false, canUndo: false, canRedo: false,
             onPublish: null,                                 // author sets a fn(patches, {log,cursor}) → route to cloud/custom

package/lib/manifest.integrity.json

@@ -1,40 +1,41 @@
 {
-  "manifest.appwrite.auth.js": "sha384-Dy5NIqlV3TdKC87VYMqikQ2kZAPGdGy7wVIqcR92XYb47v+0Dn/YTPZsJdg6YhMT",
-  "manifest.appwrite.data.js": "sha384-rBxJHvm65pKByB3p5uNmCPvm56LXOJ5BFprVuZPcEFjSbi17WBQL0q49hAXl5gxW",
+  "manifest.appwrite.auth.js": "sha384-HMJmRXnvdDBWyuteXL+DTxWM2llSCdjl4EDamEI7iHNAVlqeOCE4GDTm8ZHipPRj",
+  "manifest.appwrite.data.js": "sha384-avAqJJn65+6k2tbvGja/S0ZsEOtCEhFG93LgqODbuaP4kLaWFkVrZQwnnPJLxbIR",
   "manifest.appwrite.presences.js": "sha384-JyVDWFT69b7Svq8J8p9tNWe2v9PZNQBY5UyhtOl1vnuHFAX0CRQ3MA9SiKq5wzNh",
   "manifest.bindings.js": "sha384-lPtMf8Ykaic9gNVZKq8Scia1881ZeMAyxer3WCIkUNwwrgzGBWto1OXADUwjvORF",
   "manifest.charts.js": "sha384-qQrjhWkIDi4oU5uQrpy8DdlMjY+gfiivBuX6mssNiFdkawgkVBvKneGgp+nd3PYJ",
-  "manifest.chat.js": "sha384-5SEd0T5cInCswUcbAH7CuKYuzCu9nPoGOsCjSo22UVksHkxZ5OY78ZWTjeVQtR9M",
+  "manifest.chat.js": "sha384-88DfMfJLoi2oxclVD2iIMDkIGAExMXq5k47mekUredlicLaP3oZY5bwtwqs+TqDF",
   "manifest.code.js": "sha384-aoQ4E26vrhNe/+tL7K0h90c8/0ies7e8oIR6Ay92he2X3dnWZ+OPcn2Dna8fmc+c",
   "manifest.color.js": "sha384-6Rv3LxyTcZNjrhtayQfqRdCx0uSZ4BiEbgEI98I62eTvp8Aw7LBIoNJ0Je1oktwL",
   "manifest.colorpicker.js": "sha384-1+ZV5Hhjf7WnGP7b71Cqa5h3BKW8UgGT5V14i8Q+aF5zH8Xxwowt/ibSUVsiIHSm",
   "manifest.combobox.js": "sha384-SN3XHumoebxcduFQqx5zt65/Cd10y8nuf9Gkco6UnsZ42sadRd+gvVLfWPdkkuPH",
-  "manifest.components.js": "sha384-HEyeJtV20k7po8WH0LEj800MlsqgDH0vE5GTAl62SgdEhn1aJ7VfryQcA6yIi18U",
+  "manifest.components.js": "sha384-DLGSqCbnGkS87AWJ8GpKoAFP4nCosgC5SFSg6C10hH/nWu/MxI+0ntHlnFEfs++u",
   "manifest.computed.js": "sha384-GYML/e81gQfN+iDbqhPUgny8bINCyL+SrbTofoGk4hlCnLLjv51mCv42JMqq+ku5",
-  "manifest.data.js": "sha384-2PDbtqCZnYLWR4enzYvj93csIQX2pC1HhFDmTGFrTb3v0IS2FzZ0cgatZ6RPR50y",
+  "manifest.data.js": "sha384-Cfww6fFCDaSckoFAUvLRf7ResiGMSmmLgNeZQLe3JbqHZufiwbhRMzTyw3FaOL0l",
   "manifest.datepicker.js": "sha384-8vTJYkLqqvgXgm1w1becuaRR/jUEpiLBjBJ6RsRbUr+ZkypvspD6EsssuDrX4SQq",
-  "manifest.defer.js": "sha384-t/g++osVS3qDXeY8+gfxUtLF9o0SCQQJKNxHGpb8NkIciDvxOAvA6sFIVcM0AKeA",
+  "manifest.defer.js": "sha384-wXa60M2OHigi5rBurXQ7Oa8eyr5WTKs7EUn2GOru62KMdfs/LDyNegxCc9MNJFSe",
+  "manifest.device.js": "sha384-g+txmrEszYtuOvRelTp/c1wSNR2AtllVI9rx5NPPD7DzhVUnMNughonZykv2xlBW",
   "manifest.dropdowns.js": "sha384-4HuHkBt4i8sTPUDLB9rNLli2/lWLY1tjtCLzey37gRwueG+FRLCnVH1q7ljiVvJR",
-  "manifest.edit.js": "sha384-ZvgV3ax7yHtSC23zdvRYJPzBsBpGFBLuBJMgfQ1IDumv97Cn2bpHOePxyQikfl5L",
+  "manifest.edit.js": "sha384-oLsrH7/UkJ/KEl3UO77hexcf2rYCGgzXZd0fe2EMq3hKRE7aUqLiEnLJhSV7zTaY",
   "manifest.export.js": "sha384-HCy3n6ifrcAGIyzTRgZ5JIRvSX9q9/8ykMKRSbt1QTnhXz6PgYlV0AE2N2Yi2re+",
   "manifest.icons.js": "sha384-kKOINpX70YzNO3FvkV6umrmO3f0KIu0DNbwB+ej55a7y/lhU7v/myQtXL0bwCTbt",
   "manifest.localization.js": "sha384-p8MRlfpjQuMar7rerGRjfdRKqIPoU/QOwVmnwN+PjhrlEZNpetYLZhqO2i5BZn9s",
   "manifest.markdown.js": "sha384-HFE2VwBRX5vhDGQ3c8XgZ10Y5ENkXxHzgX9DjmIEffqLoUDbnJYNk3TFWT9k3e+f",
-  "manifest.native.js": "sha384-nIngj4CM5hV4bvQvgs8C7JmSy1UUzobsbhvDE2NH5dXqQVNW/Hiat34wHUxMqSaO",
-  "manifest.payments.js": "sha384-QGctMZtxF0Wb2JUJbb9sJ4bFbyQvUdr9HaKs4afyaTXb7zedAAIWeB27XINMe3VZ",
+  "manifest.native.js": "sha384-g+txmrEszYtuOvRelTp/c1wSNR2AtllVI9rx5NPPD7DzhVUnMNughonZykv2xlBW",
+  "manifest.payments.js": "sha384-8pofk2zhxtapPMpwnFyTelPMrYhShNhDCE722uQh/EYFvZFuPLmSdgunqsarVQjv",
   "manifest.resize.js": "sha384-+0IsyrGP/4gZmNbD6oU8dCgEyhpBsXMm74NIenYeUGuGRWyJDurcG27xE/CA0/aA",
   "manifest.router.js": "sha384-4qmGEkRpgAo9xoQkW6+hHIhowvcyAggKB2J3Wf8tJtXp+L0hufoVAqzfhnqw4cNR",
   "manifest.slides.js": "sha384-3uRTkyK9XPLmnxI2+igZlpi4EyPlU/7IHj5j3BZJJ2KN455vXyk99fiXV3feO/XY",
-  "manifest.status.js": "sha384-fXqDnKwldB7XRxcfEQYTm/WqLl2oP24xY2Znq8FqnFM9LQo0zrQkXszqAOksArUX",
+  "manifest.status.js": "sha384-nwvUSbT+gpRMqhYx6MeBYswUMH72rY92mjgxv0vrSG7Ht7l83XYpEB6fCTbXjjfK",
   "manifest.svg.js": "sha384-qr/8H9+2cIhSXNbRWRtIdrDlTOxKlNJqwEefHvCYoiBNW/kKhPTFa109Orv/EBnb",
-  "manifest.sw.js": "sha384-lzc4R7OpLBlr8VS6OfudGQVrKdEny+1etglkfsLUQ3pX0Z3JJWagy0rl/amf5xnW",
+  "manifest.sw.js": "sha384-evmpNHyxUu1Qsu2FP7buzG48O5Ppbf0ZlCn8V4Br4LiU6qrNCkfqh1yXxuafEg6Z",
   "manifest.tabs.js": "sha384-OIIcyaQnGS0eNYk4zgAFEDboNYect7THvUd9D0V6nqCeDOxQcoiqLrBEmmWVTTet",
   "manifest.tailwind.js": "sha384-r/Jvqb+Piz21jUts10BbVAJoKkShOdJRVFpywyi4HPIi/OfOJq5CtPyWAPbdkMgt",
-  "manifest.text.edit.js": "sha384-1LsuOJyMCgab7W9w6DJEu5URzbadYxtq/cHtB8sN3hBFa/BHPnjdnTRbiKyM0FcC",
+  "manifest.text.edit.js": "sha384-pfhc4IPKNJokj6ldlgD+KwGLN4UoM21CNeVf2sVq/34X1Un2PUhEuyTg5itmtsXS",
   "manifest.toasts.js": "sha384-/OV32LLMJl0Iw8NoNQJ+5lgntLxjIJq/YNj5JAKS/+nUhVx4MMB9h1FOqP7zuj2M",
   "manifest.tooltips.js": "sha384-uXVVQADl6pY2Pj9i/UaSclZN7dzbKhLkmevv7Ad0+wXR8LgqodALNFrc5jZJjlwm",
   "manifest.url.parameters.js": "sha384-J2aSVBOPsoqsbafHndrWLHEDpKb4AKJAoQnVmKA4gZh5P/8HHjFWHO/lkusmG84l",
   "manifest.utilities.js": "sha384-RvUXxxMLv5q6Psng6jjfK5O1xw05mV6BdLjV92zQW7Zuy3XWctl3QnF5XYNuPyYq",
   "manifest.virtual.js": "sha384-YwwmAsZNddajnAkLhBWtrK8edHMJOhD7cJkQi3qmm5o1Thg0wbtDU0dsfrCHKTIQ",
-  "manifest.js": "sha384-jicPS2+j2BtRtkdXC8YqGOQFi/V/E9MMjJFQ8mbDult9IG2cyzwq191W+zIl137b"
+  "manifest.js": "sha384-+rWocB3jT+iBErwbS1ZBwt24C/jhUavBduc5EzMSu8ZZooyO52LeGpW7UscLdLYx"
 }

package/lib/manifest.js

@@ -261,7 +261,7 @@
 	const PLUGIN_DEPENDENCIES = {
 		'appwrite-data': ['data'],
 		'appwrite-presences': ['data', 'appwrite-auth'],
-		'native': ['utilities']
+		'device': ['utilities']
 	};
 
 	// Derive default plugin list from manifest (only load data/localization/components when manifest needs them)
@@ -381,6 +381,7 @@
 	// entry means the fetch finished; a complete document has run every parser tag.
 	function scriptSettled(el) {
 		if (el.hasAttribute('data-mnfst-loaded')) return true;
+		if (el.hasAttribute('data-mnfst-loading')) return false;   // ours, still fetching or executing: only its load event counts
 		if (document.readyState === 'complete') return true;
 		if (!el.async && !el.defer && loaderScript && (loaderScript.compareDocumentPosition(el) & Node.DOCUMENT_POSITION_PRECEDING)) return true;
 		try { if (el.src && performance.getEntriesByName(el.src).length) return true; } catch (_) { /* no resource timing */ }
@@ -406,8 +407,9 @@
 			const script = document.createElement('script');
 			script.src = url;
 			script.async = false; // Ensure scripts execute in order
-			script.onload = () => { script.setAttribute('data-mnfst-loaded', ''); resolve(); };
-			script.onerror = () => { script.remove(); reject(new Error(`Failed to load ${url}`)); };
+			script.setAttribute('data-mnfst-loading', '');
+			script.onload = () => { script.removeAttribute('data-mnfst-loading'); script.setAttribute('data-mnfst-loaded', ''); resolve(); };
+			script.onerror = () => { script.removeAttribute('data-mnfst-loading'); script.remove(); reject(new Error(`Failed to load ${url}`)); };
 			document.head.appendChild(script);
 		});
 	}
@@ -434,7 +436,9 @@
 		const resolved = [];
 		const added = new Set();
 
+		const PLUGIN_ALIASES = { native: 'device' };   // renamed 0.5.199; the old name keeps working
 		function addPluginWithDeps(plugin) {
+			plugin = PLUGIN_ALIASES[plugin] || plugin;
 			if (added.has(plugin)) return;
 
 			const deps = PLUGIN_DEPENDENCIES[plugin];
@@ -508,7 +512,8 @@
 	// must not pull plugins in.
 	const USAGE_PLUGINS = [
 		{ magic: '$chat', plugin: 'chat' },
-		{ magic: '$presence', plugin: 'appwrite-presences' }
+		{ magic: '$presence', plugin: 'appwrite-presences' },
+		...['$share', '$secure', '$links', '$push', '$app', '$haptics', '$biometric', '$camera'].map(magic => ({ magic, plugin: 'device' }))
 	];
 	function detectUsagePlugins(alreadyLoaded) {
 		const wanted = USAGE_PLUGINS.filter(u => !alreadyLoaded.includes(u.plugin));
@@ -540,11 +545,12 @@
 		return [...found];
 	}
 
-	// Detect the native umbrella plugin. Auto-loaded inside a Capacitor container
-	// (window.Capacitor present) or when a `native` config block opts in on the web.
+	// Detect the device plugin (, , , …). Auto-loaded inside a
+	// Capacitor container, or when a `device` (formerly `native`) block opts in on the web.
 	function detectNativePlugins(manifest) {
-		if (typeof window !== 'undefined' && window.Capacitor) return ['native'];
-		if (manifest && typeof manifest === 'object' && manifest.native && typeof manifest.native === 'object') return ['native'];
+		if (typeof window !== 'undefined' && window.Capacitor) return ['device'];
+		const block = manifest && typeof manifest === 'object' ? (manifest.device ?? manifest.native) : null;
+		if (block && typeof block === 'object') return ['device'];
 		return [];
 	}
 
@@ -637,7 +643,7 @@
 	// Expose API
 	window.Manifest = {
 		loadPlugin: function (pluginName, version = DEFAULT_VERSION) {
-			const allPlugins = [...AVAILABLE_PLUGINS, ...APPWRITE_PLUGINS, ...AUTHORING_PLUGINS, 'payments', 'chat', 'native'];
+			const allPlugins = [...AVAILABLE_PLUGINS, ...APPWRITE_PLUGINS, ...AUTHORING_PLUGINS, 'payments', 'chat', 'device'];
 			if (!allPlugins.includes(pluginName)) {
 				console.warn(`[Manifest Loader] Unknown plugin: ${pluginName}`);
 				return Promise.reject(new Error(`Unknown plugin: ${pluginName}`));
@@ -710,6 +716,7 @@
 		const devServer = !!window.__mnfstRun;
 		const devOrigin = isDevHost(loc.hostname);
 		let manifest = window.__manifestLoaded || null;
+		if (!manifest && window.__manifestPromise) manifest = await window.__manifestPromise.catch(() => null);
 		if (!manifest) {
 			const url = document.querySelector('link[rel="manifest"]')?.getAttribute('href') || '/manifest.json';
 			manifest = await fetch(url).then(r => r.ok ? r.json() : null).catch(() => null);
@@ -829,13 +836,26 @@
 			walk(obj);
 		};
 
+		// One manifest.json request per boot: published on window the moment it starts so
+		// plugins that init before __manifestLoaded is set (data, auth, components) await it
+		// instead of fetching their own. Resolves interpolated, or null.
+		const shareManifestFetch = () => {
+			if (window.__manifestLoaded) return Promise.resolve(window.__manifestLoaded);
+			if (!window.__manifestPromise) {
+				window.__manifestPromise = fetch(manifestUrl).then(r => r.ok ? r.json() : null)
+					.then(m => { if (m && !m.__interpolated) { interpolateManifestEnv(m); Object.defineProperty(m, '__interpolated', { value: true, enumerable: false }); } return m; })
+					.catch(() => null);
+			}
+			return window.__manifestPromise;
+		};
+
 		const loadPlugins = async () => {
 			let manifest = null;
 			let pluginsToLoad = config.plugins;
 			let manifestPromise = null;
 
 			if (config.deriveFromManifest) {
-				manifest = await fetch(manifestUrl).then(r => r.ok ? r.json() : null).catch(() => null);
+				manifest = await shareManifestFetch();
 				const corePlugins = getDefaultPluginsFromManifest(manifest);
 				const appwritePlugins = detectAppwritePlugins(manifest);
 				const paymentsPlugins = detectPaymentsPlugins(manifest);
@@ -846,12 +866,12 @@
 				pluginsToLoad = resolveDependencies([...ALWAYS_ON, ...pluginsToLoad.filter(p => !ALWAYS_ON.includes(p))]);
 				const needsManifest = config.plugins.some(p => MANIFEST_DEPENDENT_PLUGINS.includes(p));
 				if (needsManifest) {
-					manifestPromise = fetch(manifestUrl).then(r => r.ok ? r.json() : null).catch(() => null);
+					manifestPromise = shareManifestFetch();
 				}
 				// Inside a Capacitor container, ensure the native umbrella loads even on
 				// the explicit data-plugins path (matches the derive-path auto-inject).
-				if (typeof window !== 'undefined' && window.Capacitor && !pluginsToLoad.includes('native')) {
-					pluginsToLoad = resolveDependencies([...pluginsToLoad, 'native']);
+				if (typeof window !== 'undefined' && window.Capacitor && !pluginsToLoad.includes('device')) {
+					pluginsToLoad = resolveDependencies([...pluginsToLoad, 'device']);
 				}
 			}
 
@@ -868,9 +888,7 @@
 				manifest = await manifestPromise;
 			}
 			if (manifest && typeof window !== 'undefined') {
-				// Resolve ${VAR} before any plugin reads the cached manifest —
-				// appwrite-auth etc. read window.__manifestLoaded directly.
-				interpolateManifestEnv(manifest);
+				// Already interpolated by shareManifestFetch; appwrite-auth etc. read window.__manifestLoaded directly.
 				window.__manifestLoaded = manifest;
 				if (window.ManifestComponentsRegistry) {
 					window.ManifestComponentsRegistry.manifest = manifest;

package/lib/manifest.native.js

@@ -1,4 +1,4 @@
-/* manifest.native.js — built from scripts/native/ */
+/* manifest.device.js — built from scripts/device/ */
 
 (function () {
 

package/lib/manifest.payments.js

@@ -21,10 +21,11 @@ function resolvedOrNull(value, fieldName) {
 async function ensureManifest() {
     if (window.ManifestComponentsRegistry?.manifest) return window.ManifestComponentsRegistry.manifest;
     if (window.__manifestLoaded) return window.__manifestLoaded;
+    if (window.__manifestPromise) { const shared = await window.__manifestPromise.catch(() => null); if (shared) return shared; }
     try {
         const url = document.querySelector('link[rel="manifest"]')?.getAttribute('href') || '/manifest.json';
-        const res = await fetch(url);
-        return await res.json();
+        window.__manifestPromise = fetch(url).then(r => r.json());
+        return await window.__manifestPromise;
     } catch (_) {
         return null;
     }

package/lib/manifest.schema.json

@@ -408,9 +408,14 @@
             },
             "additionalProperties": true
         },
+        "device": {
+            "type": "object",
+            "description": "Opts the app into the device plugin: $share, $secure, $links, $push, $app, $haptics, $biometric and $camera, each with a web fallback and Capacitor as the native adapter. Auto-loaded inside a Capacitor container and whenever a page uses one of those magics; an empty object loads it on every build.",
+            "additionalProperties": true
+        },
         "native": {
             "type": "object",
-            "description": "Opts the app into the native umbrella plugin — $-magics for biometric, push, haptics, share, secure storage, deep links, camera, and app lifecycle, plus $device enrichment. Auto-loaded inside a Capacitor container; declaring this block also loads it on the web build (every capability degrades gracefully off-device, with Capacitor as one adapter). An empty object is enough to opt in.",
+            "description": "Deprecated alias of `device` (renamed in 0.5.199); still accepted.",
             "additionalProperties": true
         }
     },

package/lib/manifest.status.js

@@ -64,13 +64,14 @@
     // cache a normalized copy that omits keys they don't consume.
     async function ensureStatusManifest() {
         const cached = window.ManifestComponentsRegistry?.manifest || window.__manifestLoaded;
-        if (cached && cached.status) return cached;
+        if (cached) return cached;   // a loaded manifest without `status` means no status config, not a stale copy
+        if (window.__manifestPromise) { const shared = await window.__manifestPromise.catch(() => null); if (shared) return shared; }
         try {
             const url = document.querySelector('link[rel="manifest"]')?.getAttribute('href') || '/manifest.json';
-            const res = await fetch(url);
-            return await res.json();
+            window.__manifestPromise = fetch(url).then(r => r.json());
+            return await window.__manifestPromise;
         } catch (_) {
-            return cached || null;
+            return null;
         }
     }
 

package/lib/manifest.sw.js

@@ -16,7 +16,7 @@
 
 // Build stamps the published version here; unstamped (dev) falls back to the
 // registration URL's `v`, then 'dev'.
-const BUILD_VERSION = '0.5.199-next.2';
+const BUILD_VERSION = '0.5.199-next.4';
 const CACHE_PREFIX = 'mnfst-sw:';
 const META_CACHE = CACHE_PREFIX + 'meta';
 const SWR_CAP = 200;

package/lib/manifest.text.edit.js

@@ -1563,9 +1563,9 @@
     // Letting go of the target has to be announced. A menu anchored to the selection
     // is watching for it, and without a final null it hangs about over content it no
     // longer has anything to do with.
-    function release() {
-        const was = lastFocused;
-        lastFocused = null;
+    function release(area) {
+        const was = area || lastFocused;
+        if (!area || area === lastFocused) lastFocused = null;
         if (!was) return;
         was._selection = null;
         was.removeAttribute('data-text-edit-selected');
@@ -1573,6 +1573,19 @@
         was.dispatchEvent(new CustomEvent('text-edit:selection', { bubbles: true, detail: null }));
     }
 
+    // relatedTarget is null for a click onto plain page text; the pointer that caused
+    // the blur stands in, and only for the tick that dispatched it.
+    let pointerTarget = null;
+
+    // Focus is still the area's own, or on a control that acts on it.
+    function keeps(area, node) {
+        const el = elementAt(node);
+        if (!el) return false;
+        if (area.contains(el)) return true;
+        const control = el.closest('[data-text-edit-control]');
+        return !!control && resolve(control) === area;
+    }
+
     const editableElsewhere = (node) => {
         const el = elementAt(node);
         return !!el && (el.isContentEditable || /^(INPUT|TEXTAREA)$/.test(el.tagName));
@@ -1650,6 +1663,19 @@
         sync();
     }
 
+    // A link at the caret comes off; a selection gets one, through the area's own url
+    // control where there is one.
+    function toggleLink(area) {
+        if (ancestor('a')) { run(area, 'a'); return; }
+        if (!hasSelection()) return;
+        saveRange(area);
+        const field = [...controls].find(c => c._te && c._te.id === 'a' && !c._te.page
+            && 'value' in c && c.tagName !== 'BUTTON' && resolve(c) === area);
+        if (field) { field.focus(); if (field.select) field.select(); return; }
+        const url = typeof window.prompt === 'function' ? window.prompt('Link URL', '') : null;
+        if (url) run(area, 'a', url);
+    }
+
     // Reflect caret state onto every control pointing at the area that owns it.
     function sync() {
         controls.forEach(c => {
@@ -1695,10 +1721,18 @@
             };
         });
 
+        document.addEventListener('pointerdown', (e) => {
+            pointerTarget = e.target;
+            setTimeout(() => { pointerTarget = null; }, 0);
+        }, true);
+
         document.addEventListener('selectionchange', () => {
             const r = range(); if (!r) return;
             const a = [...areas].find(x => x.contains(r.startContainer));
-            if (a) { saveRange(a); lastFocused = a; report(a); }
+            if (a) {
+                if (lastFocused && lastFocused !== a) release(lastFocused);   // the one being left owes a null
+                saveRange(a); lastFocused = a; report(a);
+            }
             else if (lastFocused && editableElsewhere(r.startContainer)) release();
             sync();
         });
@@ -1894,6 +1928,12 @@
         });
 
         el.addEventListener('focusin', () => { lastFocused = el; sync(); });
+        // Focus gone somewhere that is neither this area nor one of its controls.
+        el.addEventListener('focusout', (e) => {
+            if (keeps(el, e.relatedTarget || pointerTarget)) return;
+            release(el);
+            sync();
+        });
         el.addEventListener('input', (e) => {
             if (!writing && e.data && applyPending(el, e.data)) { commitValue(); }
             settle(); sync();
@@ -1967,7 +2007,8 @@
             const id = { b: 'strong', i: 'em', u: 'u', k: 'a' }[e.key.toLowerCase()];
             if (!id || !allows(el, id)) return;
             e.preventDefault();
-            run(el, id, id === 'a' ? undefined : undefined);
+            if (id === 'a') { toggleLink(el); return; }
+            run(el, id);
         });
 
         // Paste as our own subset — never the source app's markup.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mnfst",
-    "version": "0.5.199-next.2",
+    "version": "0.5.199-next.4",
     "private": false,
     "workspaces": [
         "templates/starter",