rosefc 0.2.0 → 0.2.1

package/src/runtime/index.ts

@@ -64,7 +64,7 @@ function untrack<T>(fn: () => T): T {
 }
 
 // Trade-off: global signal map, shared across all inlined modules
-const signalMap: Map<string, SignalEntry> = shared('__rosefd_signalMap', () => new Map());
+const signalMap: Map<string, SignalEntry> = shared('__rosefc_signalMap', () => new Map());
 
 // One get-or-create helper shared by state / setState / resumeState.
 function entry(key: string, initial: unknown): { value: unknown; subs: Set<Subscriber> } {
@@ -125,7 +125,7 @@ export function hasState(key: string): boolean {
 }
 
 // === Per-RENDER $data seeding === The compiled `$data(() => loader())` prologue is const __seeded = isSeeded("k"); const [get.
-const seededKeys: Set<string> = shared('__rosefd_seededKeys', () => new Set());
+const seededKeys: Set<string> = shared('__rosefc_seededKeys', () => new Set());
 
 export function isSeeded(key: string): boolean {
   return renderMaps().seeded.has(key);
@@ -155,12 +155,12 @@ export function setState<T>(key: string, value: T): void {
   if (persistedKeys.has(key)) writeStorage(key, value);
 }
 
-// F9 ($persist): keys declared with $persist survive reloads — every write lands in localStorage (JSON-encoded under a rosefd: prefix) and every client.
-const persistedKeys: Set<string> = shared('__rosefd_persistedKeys', () => new Set());
+// F9 ($persist): keys declared with $persist survive reloads — every write lands in localStorage (JSON-encoded under a rosefc: prefix) and every client.
+const persistedKeys: Set<string> = shared('__rosefc_persistedKeys', () => new Set());
 
 function writeStorage(key: string, v: unknown): void {
   try {
-    (globalThis as { localStorage?: Storage }).localStorage?.setItem('rosefd:' + key, JSON.stringify(v));
+    (globalThis as { localStorage?: Storage }).localStorage?.setItem('rosefc:' + key, JSON.stringify(v));
   } catch {  }
 }
 
@@ -170,7 +170,7 @@ export function persistState<T>(key: string, initial: T): [() => T, (v: T) => vo
   let seeded = initial;
   let hasStored = false;
   try {
-    const raw = (globalThis as { localStorage?: Storage }).localStorage?.getItem('rosefd:' + key);
+    const raw = (globalThis as { localStorage?: Storage }).localStorage?.getItem('rosefc:' + key);
     if (raw != null) {
       seeded = JSON.parse(raw) as T;
       hasStored = true;
@@ -184,7 +184,7 @@ export function persistState<T>(key: string, initial: T): [() => T, (v: T) => vo
 }
 
 // F12: the error a {#boundary} just caught — a custom {:fallback} reads it ({$boundaryError()?.message}) to render its own failure UX.
-const lastBoundaryError = sharedCell<Error | null>('__rosefd_lastBoundaryError', null);
+const lastBoundaryError = sharedCell<Error | null>('__rosefc_lastBoundaryError', null);
 
 export function $setBoundaryError(e: unknown): void {
   lastBoundaryError.value = e instanceof Error ? e : new Error(String(e));
@@ -195,12 +195,12 @@ export function $boundaryError(): Error | null {
 }
 
 
-const cleanups: Set<Cleanup> = shared('__rosefd_cleanups', () => new Set());
+const cleanups: Set<Cleanup> = shared('__rosefc_cleanups', () => new Set());
 
 
 let fxOwner: object | null = null;
-const fxByOwner: WeakMap<object, Set<Cleanup>> = shared('__rosefd_fxByOwner', () => new WeakMap());
-const keysByOwner: WeakMap<object, Set<string>> = shared('__rosefd_keysByOwner', () => new WeakMap());
+const fxByOwner: WeakMap<object, Set<Cleanup>> = shared('__rosefc_fxByOwner', () => new WeakMap());
+const keysByOwner: WeakMap<object, Set<string>> = shared('__rosefc_keysByOwner', () => new WeakMap());
 const fxSet = (): Set<Cleanup> => {
   if (!fxOwner) return cleanups;
   let s = fxByOwner.get(fxOwner);
@@ -412,7 +412,7 @@ interface EachRow {
 // attribute (apps use it for active-row styling), its value is part of the html
 // the reuse check compares, and it carries no closure - forbidding it forced a
 // full rebuild of every such list on any selection change.
-const EACH_REUSE_FORBID = /data-on-|data-use|data-bind-this|data-transition|data-animate|data-rosefd-c|data-rv-island/;
+const EACH_REUSE_FORBID = /data-on-|data-use|data-bind-this|data-transition|data-animate|data-rosefc-c|data-rv-island/;
 const EACH_HTML_NORM = (h: string): string => h.replace(/\u27e6\/?[a-z]+:\d+\u27e7/g, '').replace(/data-b\d+/g, 'data-b');
 const normHtml = (row: EachRow): string => (row.norm ??= EACH_HTML_NORM(row.html));
 
@@ -481,12 +481,12 @@ export function slotBlockMark(
 const MARK_RE = /^\u27e6([milh]):(\d+)\u27e7$/;
 const END_RE = /^\u27e6\/([milh]):(\d+)\u27e7$/;
 
-const wired: WeakSet<Node> = shared('__rosefd_wired', () => new WeakSet());
+const wired: WeakSet<Node> = shared('__rosefc_wired', () => new WeakSet());
 
-const pendingIslandObservers: Set<IntersectionObserver> = shared('__rosefd_pendingIslandObservers', () => new Set());
+const pendingIslandObservers: Set<IntersectionObserver> = shared('__rosefc_pendingIslandObservers', () => new Set());
 
 const TPL_CACHE_MAX = 512;
-const tplCache: Map<string, HTMLTemplateElement> = shared('__rosefd_tplCache', () => new Map());
+const tplCache: Map<string, HTMLTemplateElement> = shared('__rosefc_tplCache', () => new Map());
 
 /** Parse an html string into a DocumentFragment. Parsed templates are cached per string and cloned per call, so repeated renders (keyed each rows, if-branch re-entry) skip the innerHTML parse. */
 export function tpl(html: string): DocumentFragment {
@@ -503,21 +503,21 @@ export function tpl(html: string): DocumentFragment {
   return t.content.cloneNode(true) as DocumentFragment;
 }
 
-const HEAD_ATTR = 'data-rosefd-head';
+const HEAD_ATTR = 'data-rosefc-head';
 
 export const handlers: Record<string, (e: Event) => void> =
-  (globalThis as { __rosefd_handlers?: Record<string, (e: Event) => void> }).__rosefd_handlers ??= {};
+  (globalThis as { __rosefc_handlers?: Record<string, (e: Event) => void> }).__rosefc_handlers ??= {};
 
 // The action dispatcher the client entry installs. Shared, not per-copy: the
 // elements it dispatches for are in the one document every copy wires, so the
 // last entry to install wins for all of them - the same rule `handlers` and
 // `directives` already follow.
-const actionDispatchCell = sharedCell<((name: string, e: Event) => void) | null>('__rosefd_actionDispatch', null);
+const actionDispatchCell = sharedCell<((name: string, e: Event) => void) | null>('__rosefc_actionDispatch', null);
 export function setActionDispatcher(fn: (name: string, e: Event) => void): void {
   actionDispatchCell.value = fn;
 }
 
-const directBound: WeakMap<Element, Set<string>> = shared('__rosefd_directBound', () => new WeakMap());
+const directBound: WeakMap<Element, Set<string>> = shared('__rosefc_directBound', () => new WeakMap());
 
 /**
  * F5: `use:NAME` element actions - the plugin point for DOM behaviors
@@ -529,10 +529,10 @@ const directBound: WeakMap<Element, Set<string>> = shared('__rosefd_directBound'
  * of the reactive graph keeps the action contract one argument.
  */
 export const directives: Record<string, (el: Element, param?: unknown) => void | (() => void) | { update?: (p: unknown) => void; destroy?: () => void }> =
-  (globalThis as { __rosefd_directives?: Record<string, (el: Element, param?: unknown) => void | (() => void) | { update?: (p: unknown) => void; destroy?: () => void }> })
-    .__rosefd_directives ??= {};
+  (globalThis as { __rosefc_directives?: Record<string, (el: Element, param?: unknown) => void | (() => void) | { update?: (p: unknown) => void; destroy?: () => void }> })
+    .__rosefc_directives ??= {};
 
-const actionRecords: WeakMap<Element, { update?: (p: unknown) => void; destroy?: () => void }> = shared('__rosefd_actionRecords', () => new WeakMap());
+const actionRecords: WeakMap<Element, { update?: (p: unknown) => void; destroy?: () => void }> = shared('__rosefc_actionRecords', () => new WeakMap());
 
 /**
  * Apply one route's whole <head> (every block of its chain, page first) to the
@@ -603,7 +603,7 @@ function linkIdentitySuffix(rel: string, el: Element): string {
   return `@${el.getAttribute('href') ?? el.getAttribute('type') ?? el.getAttribute('as') ?? ''}`;
 }
 
-/** Drop every Rosefd-managed head element (routes without <head> blocks). */
+/** Drop every Rosefc-managed head element (routes without <head> blocks). */
 export function clearHead(): void {
   document.head.querySelectorAll(`[${HEAD_ATTR}]`).forEach((el) => el.remove());
 }
@@ -1031,7 +1031,7 @@ export function wire(root: Node, closes: Array<unknown>, scope?: unknown): Clean
               }, duration + delay);
             });
           } else {
-            const custom = (globalThis as any).__rosefdTransitions?.[name];
+            const custom = (globalThis as any).__rosefcTransitions?.[name];
             if (custom) {
               const ret = custom(el, duration, 'out');
               if (typeof ret === 'function') created.push(ret);
@@ -1077,7 +1077,7 @@ export function wire(root: Node, closes: Array<unknown>, scope?: unknown): Clean
             }, duration + delay);
           });
         } else {
-          const custom = (globalThis as any).__rosefdTransitions?.[name];
+          const custom = (globalThis as any).__rosefcTransitions?.[name];
           if (custom) {
             const ret = custom(el, duration, dir || 'both');
             if (typeof ret === 'function') created.push(ret);
@@ -1491,7 +1491,7 @@ export function $data<T>(fn: () => T | Promise<T>): Promise<T> {
   return p as Promise<T>;
 }
 
-const bffCache: Map<string, Promise<unknown>> = shared('__rosefd_bffCache', () => new Map());
+const bffCache: Map<string, Promise<unknown>> = shared('__rosefc_bffCache', () => new Map());
 
 export function loader<T>(key: string, fn: () => Promise<T>): Promise<T> {
   let p = bffCache.get(key) as Promise<T> | undefined;
@@ -1597,7 +1597,7 @@ export async function isolateRender<T>(fn: () => Promise<T>): Promise<T> {
 // The tail of the fallback render queue; see isolateRender. Shared across
 // bundle copies because the tables the renders swap are shared; a module-level
 // mutex would order one copy's renders and let another copy's interleave.
-const renderMutexCell = sharedCell<Promise<void>>('__rosefd_renderMutex', Promise.resolve());
+const renderMutexCell = sharedCell<Promise<void>>('__rosefc_renderMutex', Promise.resolve());
 
 let requestQuery: Record<string, string> = {};
 /** R248: the request-scoped query slot in the context-store bag. */
@@ -1712,7 +1712,7 @@ type RenderMaps = { data: Map<string, Promise<unknown>>; signals: Map<string, Si
 // same single-render maps, so a $data promise or a seeded key written by one
 // copy's render is visible to the next one's - which is exactly what a
 // client-side navigation between two separately-bundled routes needs.
-const fallbackRenderMaps: RenderMaps = shared('__rosefd_fallbackRenderMaps', () => ({ data: new Map(), signals: signalMap, seeded: seededKeys }));
+const fallbackRenderMaps: RenderMaps = shared('__rosefc_fallbackRenderMaps', () => ({ data: new Map(), signals: signalMap, seeded: seededKeys }));
 
 function renderMaps(): RenderMaps {
   // The store's map-of-maps is typed Record<string, unknown> but carries symbol
@@ -1859,8 +1859,8 @@ export function resumeState(json: string): void {
 }
 
 const SDUI_TAGS = ['div', 'span', 'a', 'p', 'img', 'ul', 'li', 'button', 'input', 'section', 'h1', 'h2', 'h3', 'nav', 'header', 'footer', 'form', 'label', 'strong', 'em', 'table', 'tr', 'td', 'code', 'pre', 'article', 'main', 'aside'];
-const sduiTagToId: Map<string, number> = shared('__rosefd_sduiTagToId', () => new Map(SDUI_TAGS.map((t, i) => [t, i])));
-const sduiIdToTag: Map<number, string> = shared('__rosefd_sduiIdToTag', () => new Map(SDUI_TAGS.map((t, i) => [i, t])));
+const sduiTagToId: Map<string, number> = shared('__rosefc_sduiTagToId', () => new Map(SDUI_TAGS.map((t, i) => [t, i])));
+const sduiIdToTag: Map<number, string> = shared('__rosefc_sduiIdToTag', () => new Map(SDUI_TAGS.map((t, i) => [i, t])));
 
 export interface SduiNode {
   t: string;
@@ -1889,7 +1889,7 @@ export function decodeSdui(json: string): SduiNode {
 
 // The SWR refresh hook the client entry installs - shared like the action
 // dispatcher: it drives the one document every copy wired, last install wins.
-const refreshHookCell = sharedCell<(() => Promise<void>) | null>('__rosefd_refreshHook', null);
+const refreshHookCell = sharedCell<(() => Promise<void>) | null>('__rosefc_refreshHook', null);
 
 export function setRefreshHook(fn: () => Promise<void>): void {
   refreshHookCell.value = fn;
@@ -1900,7 +1900,7 @@ export function refresh(): Promise<void> {
   return hook ? hook() : Promise.resolve();
 }
 
-const mountQueue: Array<() => void> = shared('__rosefd_mountQueue', () => []);
+const mountQueue: Array<() => void> = shared('__rosefc_mountQueue', () => []);
 
 export function onMount(fn: () => void): void {
   if (typeof document === 'undefined') return;
@@ -1942,7 +1942,7 @@ const localeCell = sharedCell<{
   dicts: Record<string, Record<string, string>>;
   def: string;
   packs: string[];
-}>('__rosefd_localeCell', { dicts: {}, def: 'en', packs: [] });
+}>('__rosefc_localeCell', { dicts: {}, def: 'en', packs: [] });
 
 export function setLocales(dicts: Record<string, Record<string, string>>, def: string): void {
   const c = localeCell.value;
@@ -2015,7 +2015,7 @@ export function bestLocale(header: string | null | undefined): string | null {
 
 /** The signal `redirect()` throws. */
 export class RoseRedirect extends Error {
-  readonly __rosefd = 'redirect';
+  readonly __rosefc = 'redirect';
   constructor(readonly path: string, readonly status = 307) {
     super(`redirect to ${path}`);
   }
@@ -2023,7 +2023,7 @@ export class RoseRedirect extends Error {
 
 /** The signal `notFound()` throws. */
 export class RoseNotFound extends Error {
-  readonly __rosefd = 'notFound';
+  readonly __rosefc = 'notFound';
   constructor() {
     super('notFound()');
   }
@@ -2066,7 +2066,7 @@ export function localeDir(lang: string): string {
 const ICU_RE = /\{([\w$]+),\s*(plural|selectordinal|select),\s*((?:\s*[=\w]+\s*\{(?:[^{}]|\{[^{}]*\})*\})*)\}/g;
 const BRANCH_RE = /([=\w]+)\s*\{((?:[^{}]|\{[^{}]*\})*)\}/g;
 
-const PLURAL_RULES: Map<string, Intl.PluralRules> = shared('__rosefd_pluralRules', () => new Map());
+const PLURAL_RULES: Map<string, Intl.PluralRules> = shared('__rosefc_pluralRules', () => new Map());
 
 /** The CLDR category of `n` in `locale`, or null where Intl has no answer. */
 function pluralCategory(locale: string, ordinal: boolean, n: number): string | null {
@@ -2115,11 +2115,11 @@ export function $t(key: string, vars?: Record<string, string | number>): string
   return out;
 }
 
-const STORES: Map<string, { value: unknown; subs: Set<Subscriber> }> = shared('__rosefd_stores', () => new Map());
+const STORES: Map<string, { value: unknown; subs: Set<Subscriber> }> = shared('__rosefc_stores', () => new Map());
 // The SSE transport for $store - shared like the dispatcher and the refresh
 // hook: it is installed once per page by the client entry, and every copy's
 // store writes must travel over the one channel that entry opened.
-const storeTransportCell = sharedCell<((name: string, value: unknown) => void) | null>('__rosefd_storeTransport', null);
+const storeTransportCell = sharedCell<((name: string, value: unknown) => void) | null>('__rosefc_storeTransport', null);
 
 // A store write (or an applied patch) fans out to whoever read the store inside a
 // tracked scope - the wire() effects that render {store.get()} / {#each store.get()}.
@@ -2198,7 +2198,7 @@ export function $store<T>(name: string, initial: T): { get(): T; set(v: T): void
 // === Network listeners (isomorphic) ===
 // $udp / $tcp / $listen / $websocket let an app open a socket and react to the
 // outside world (LoRa gateways, MQTT-ish feeds, raw TCP devices, live dashboards)
-// from inside a Rosefd app. They only REGISTER a spec here; the host binds them
+// from inside a Rosefc app. They only REGISTER a spec here; the host binds them
 // via __startNetwork() at serve-worker boot - so a build, a prerender, or a dev
 // hot-re-import never opens a socket. The registries live on globalThis: a dev
 // re-import re-registers specs against the same live handles.
@@ -2212,10 +2212,10 @@ export function $store<T>(name: string, initial: T): { get(): T; set(v: T): void
 // ReferenceError.
 type NetOpts = Record<string, unknown>;
 const __netSpecs: { kind: string; port: number; host?: string; opts: NetOpts }[] =
-  (globalThis as any).__rosefd_netSpecs || ((globalThis as any).__rosefd_netSpecs = []);
-const __netHandles: any[] = (globalThis as any).__rosefd_netHandles || ((globalThis as any).__rosefd_netHandles = []);
+  (globalThis as any).__rosefc_netSpecs || ((globalThis as any).__rosefc_netSpecs = []);
+const __netHandles: any[] = (globalThis as any).__rosefc_netHandles || ((globalThis as any).__rosefc_netHandles = []);
 /** key ('kind:port:host') -> live handle. A Map, not a Set: re-registering a key (per-request render or dev hot re-import) swaps the callbacks in place. */
-const __netBound: Map<string, any> = (globalThis as any).__rosefd_netBound || ((globalThis as any).__rosefd_netBound = new Map());
+const __netBound: Map<string, any> = (globalThis as any).__rosefc_netBound || ((globalThis as any).__rosefc_netBound = new Map());
 
 function __netBind(spec: { kind: string; port: number; host?: string; opts: NetOpts }): void {
   const key = spec.kind + ':' + spec.port + ':' + (spec.host || '');
@@ -2227,18 +2227,18 @@ function __netBind(spec: { kind: string; port: number; host?: string; opts: NetO
   }
   const o = spec.opts || {};
   if (spec.kind === 'udp') {
-    const dg = (globalThis as any).__rosefd_dgram;
+    const dg = (globalThis as any).__rosefc_dgram;
     if (!dg) return;
     const handle = { opts: o, sock: null as any };
     const sock = dg.createSocket('udp4');
     handle.sock = sock;
     sock.on('message', (msg: Buffer, rinfo: unknown) => (handle.opts.onMessage as (m: Buffer, r: unknown) => void)?.(msg, rinfo));
-    sock.on('error', (err: Error) => { if (handle.opts.onError) (handle.opts.onError as (e: Error) => void)(err); else console.error('[rosefd] UDP error:', err); });
+    sock.on('error', (err: Error) => { if (handle.opts.onError) (handle.opts.onError as (e: Error) => void)(err); else console.error('[rosefc] UDP error:', err); });
     sock.bind(spec.port, spec.host || '0.0.0.0');
     __netHandles.push(sock);
     __netBound.set(key, handle);
   } else if (spec.kind === 'tcp') {
-    const nt = (globalThis as any).__rosefd_net;
+    const nt = (globalThis as any).__rosefc_net;
     if (!nt) return;
     const handle = { opts: o, srv: null as any };
     const idleMs = ((o.idleTimeout as number) ?? 0) * 1000;
@@ -2260,13 +2260,13 @@ function __netBind(spec: { kind: string; port: number; host?: string; opts: NetO
       socket.on('error', () => {});
     });
     handle.srv = srv;
-    srv.on('error', (err: Error) => console.error('[rosefd] TCP server error:', err));
+    srv.on('error', (err: Error) => console.error('[rosefc] TCP server error:', err));
     srv.listen(spec.port, spec.host || '0.0.0.0');
     __netHandles.push(srv);
     __netBound.set(key, handle);
   } else if (spec.kind === 'ws') {
-    const http = (globalThis as any).__rosefd_http;
-    const cryptoMod = (globalThis as any).__rosefd_crypto;
+    const http = (globalThis as any).__rosefc_http;
+    const cryptoMod = (globalThis as any).__rosefc_crypto;
     if (!http || !cryptoMod) return;
     const clients = new Set<any>();
     const handle = {
@@ -2296,7 +2296,7 @@ function __netBind(spec: { kind: string; port: number; host?: string; opts: NetO
       clients.add(wrapped);
       (opts.onConnection as (ws: unknown) => void)?.(wrapped);
     });
-    srv.on('error', (err: Error) => { if (handle.opts.onError) (handle.opts.onError as (e: Error) => void)(err); else console.error('[rosefd] WebSocket server error:', err); });
+    srv.on('error', (err: Error) => { if (handle.opts.onError) (handle.opts.onError as (e: Error) => void)(err); else console.error('[rosefc] WebSocket server error:', err); });
     srv.listen(spec.port, spec.host || '0.0.0.0');
     // Keepalive: a half-open peer (network partition, crashed device) never
     // sends FIN, so its socket would sit in `clients` forever and every
@@ -2317,7 +2317,7 @@ function __netBind(spec: { kind: string; port: number; host?: string; opts: NetO
     __netHandles.push(handle);
     __netBound.set(key, handle);
   } else if (spec.kind === 'mqtt') {
-    const nt = (globalThis as any).__rosefd_net;
+    const nt = (globalThis as any).__rosefc_net;
     if (!nt) return;
     const client = __mqttConnect(nt, spec.port, spec.host || 'localhost', o);
     __netHandles.push(client);
@@ -2327,7 +2327,7 @@ function __netBind(spec: { kind: string; port: number; host?: string; opts: NetO
 function __netReg(kind: string, port: number, host: string | undefined, opts: NetOpts): void {
   const spec = { kind, port, host, opts };
   __netSpecs.push(spec);
-  if ((globalThis as any).__rosefd_netStarted === true) __netBind(spec);
+  if ((globalThis as any).__rosefc_netStarted === true) __netBind(spec);
 }
 /** Drop every pending spec for a key and close its live handle (app-level close()). */
 function __netUnreg(kind: string, port: number, host: string | undefined): void {
@@ -2345,7 +2345,7 @@ function __netUnreg(kind: string, port: number, host: string | undefined): void
 }
 /** Bind every registered listener. Called once at serve-worker boot by the host. */
 export function __startNetwork(): void {
-  (globalThis as any).__rosefd_netStarted = true;
+  (globalThis as any).__rosefc_netStarted = true;
   for (const spec of __netSpecs) __netBind(spec);
 }
 /** Close every bound listener. Called on worker shutdown. */
@@ -2505,7 +2505,7 @@ export function $tcp(portOrHost: number | string, opts: NetOpts = {}): any {
     __netReg('tcp', port, opts.host as string | undefined, opts);
     return { ...__NOOP_NET, address: () => ({ port, host: (opts.host as string) || '0.0.0.0' }) };
   }
-  const nt = (globalThis as any).__rosefd_net;
+  const nt = (globalThis as any).__rosefc_net;
   if (!nt) return { ...__NOOP_NET };
   const host = typeof portOrHost === 'string' ? portOrHost : (opts.host as string);
   const sock = nt.createConnection({ host, port: opts.port as number });
@@ -2569,7 +2569,7 @@ export function $mqtt(broker: string, opts: NetOpts = {}): any {
       if (h) return (h.connect as () => Promise<void>)();
       __netBind({ kind: 'mqtt', port, host, opts });
       const h2 = bound();
-      return h2 ? (h2.connect as () => Promise<void>)() : Promise.reject(new Error('[rosefd] MQTT client unavailable (node:net not injected)'));
+      return h2 ? (h2.connect as () => Promise<void>)() : Promise.reject(new Error('[rosefc] MQTT client unavailable (node:net not injected)'));
     },
     disconnect: () => { (bound() as { disconnect?: () => void } | undefined)?.disconnect?.(); },
     subscribe: (topic: string, sopts: NetOpts = {}) => { (bound() as { subscribe?: (t: string, s: NetOpts) => void } | undefined)?.subscribe?.(topic, sopts); },
@@ -2749,7 +2749,7 @@ function __mqttConnect(nt: any, port: number, host: string, o: NetOpts): any {
       const password = opts.password as string | undefined;
       if (username) flags |= 0x80;
       if (password) flags |= 0x40;
-      const parts: Buffer[] = [__mqttStr('MQTT'), Buffer.from([4]), Buffer.from([flags]), __mqttU16((opts.keepalive as number) ?? 60), __mqttStr((opts.clientId as string) || ('rosefd_' + Math.random().toString(16).slice(2, 10)))];
+      const parts: Buffer[] = [__mqttStr('MQTT'), Buffer.from([4]), Buffer.from([flags]), __mqttU16((opts.keepalive as number) ?? 60), __mqttStr((opts.clientId as string) || ('rosefc_' + Math.random().toString(16).slice(2, 10)))];
       if (username) parts.push(__mqttStr(username));
       if (password) parts.push(__mqttStr(password));
       s.write(__mqttPacket(1, 0, Buffer.concat(parts)));
@@ -2777,7 +2777,7 @@ function __mqttConnect(nt: any, port: number, host: string, o: NetOpts): any {
             resolveAck();
             (client.opts.onConnect as (() => void) | undefined)?.();
           } else {
-            const err = new Error('[rosefd] MQTT broker refused the connection (code ' + (pkt.body[1] ?? '?') + ')');
+            const err = new Error('[rosefc] MQTT broker refused the connection (code ' + (pkt.body[1] ?? '?') + ')');
             rejectAck(err);
             (client.opts.onError as ((e: Error) => void) | undefined)?.(err);
           }
@@ -2803,7 +2803,7 @@ function __mqttConnect(nt: any, port: number, host: string, o: NetOpts): any {
       client.connected = false;
       if (client.__keepalive) { clearInterval(client.__keepalive); client.__keepalive = null; }
       if (client.__closed) return; // an app-level disconnect() is final
-      rejectAck(new Error('[rosefd] MQTT connection closed before CONNACK'));
+      rejectAck(new Error('[rosefc] MQTT connection closed before CONNACK'));
       scheduleReconnect();
     });
     s.on('error', (err: Error) => {
@@ -2870,7 +2870,7 @@ export function $actionErrorOrThrow(): void {
 
 /** The {#boundary} fallback: the action's own message when the failure is a business one. */
 export function $boundaryFallback(err: unknown): string {
-  if (err instanceof ActionError) return `<p class="rosefd-action-error">${esc(err.message)}</p>`;
+  if (err instanceof ActionError) return `<p class="rosefc-action-error">${esc(err.message)}</p>`;
   return '<p>This section failed to render.</p>';
 }
 
@@ -2889,7 +2889,7 @@ export const $prepend = (value: unknown): StateDelta => new StateDelta('p', valu
 /** Shallow-merge an object into an object-valued state key. */
 export const $merge = (value: Record<string, unknown>): StateDelta => new StateDelta('m', value);
 
-const pendingDeltas: Map<string, StateDelta> = shared('__rosefd_pendingDeltas', () => new Map());
+const pendingDeltas: Map<string, StateDelta> = shared('__rosefc_pendingDeltas', () => new Map());
 
 /** Record the deltas of the action that just ran (the dispatch calls this). */
 export function setStateDelta(key: string, delta: StateDelta): void {
@@ -2961,10 +2961,10 @@ export function $sessionCookie(
 export function reportVitals(): void {
   if (typeof window === 'undefined' || typeof performance === 'undefined') return;
   const live: Record<string, number> = {};
-  (window as unknown as { __rosefd_vitals?: Record<string, number> }).__rosefd_vitals = live;
+  (window as unknown as { __rosefc_vitals?: Record<string, number> }).__rosefc_vitals = live;
   const send = (name: string, value: number) => {
     live[name] = value;
-    window.dispatchEvent(new CustomEvent('rosefd:vitals', { detail: { name, value, route: location.pathname } }));
+    window.dispatchEvent(new CustomEvent('rosefc:vitals', { detail: { name, value, route: location.pathname } }));
   };
   const nav = performance.getEntriesByType?.('navigation')?.[0] as PerformanceNavigationTiming | undefined;
   if (nav) send('ttfb', Math.round(nav.responseStart));

package/src/types/{rosefd.d.ts → rosefc.d.ts}

@@ -19,12 +19,12 @@ declare function $setState<T>(key: string, value: T): void;
 /**
  * Computed state: compiles to a plain getter over the signals the expression
  * reads, so every read recomputes - no subscription machinery, never
- * serialized. Top-level declarations only. The expression is Rosefd syntax
+ * serialized. Top-level declarations only. The expression is Rosefc syntax
  * (bare state reads are callified at compile time), so it checks as `any`.
  */
 declare function $derived(expr: any): Getter<any>;
 
-/** Like $state, but every write mirrors to localStorage (JSON, `rosefd:` prefix) and boot re-seeds from it. */
+/** Like $state, but every write mirrors to localStorage (JSON, `rosefc:` prefix) and boot re-seeds from it. */
 declare function $persist<T>(initial: T): Getter<T>;
 
 /**
@@ -116,9 +116,9 @@ declare function bestLocale(header: string | null | undefined): string | null;
 
 // === Globals the compiler injects when a route uses them ===
 // These live on globalThis in the built bundle; declaring them here keeps
-// `rosefd check` honest about code that reaches for them directly.
+// `rosefc check` honest about code that reaches for them directly.
 
-declare var __rosefdAuth: {
+declare var __rosefcAuth: {
   hashPassword(pw: string): string;
   verifyPassword(pw: string, hash: string): boolean;
   signSession(data: Record<string, unknown>, secret: string, ttlSeconds?: number): string;
@@ -127,7 +127,7 @@ declare var __rosefdAuth: {
   verifyCsrf(token: string, secret: string, sessionId: string): boolean;
 };
 
-declare var __rosefdKvApi: {
+declare var __rosefcKvApi: {
   kv: {
     get(key: string): unknown;
     set(key: string, value: unknown, ttlSeconds?: number): void;
@@ -137,7 +137,7 @@ declare var __rosefdKvApi: {
   kvMemo: typeof $kv;
 };
 
-interface RosefdContentEntry {
+interface RosefcContentEntry {
   slug: string;
   title?: string;
   date?: string;
@@ -151,13 +151,13 @@ interface RosefdContentEntry {
   [key: string]: unknown;
 }
 
-declare var __rosefdContent: {
+declare var __rosefcContent: {
   list(coll: string, filter?: { tag: string }): Array<Record<string, unknown>>;
   rss(coll: string, opts: { title: string; origin: string; description: string }): string;
-  get(coll: string, slug: string, vars?: Record<string, string>): RosefdContentEntry | null;
+  get(coll: string, slug: string, vars?: Record<string, string>): RosefcContentEntry | null;
 };
 
-declare var __rosefdExtras: {
+declare var __rosefcExtras: {
   v: {
     validate(body: Record<string, unknown>, rules: Record<string, string[]>): {
       ok: boolean;
@@ -167,8 +167,8 @@ declare var __rosefdExtras: {
   };
 };
 
-/** Named view transitions: `globalThis.__rosefdTransitions.pulse = (el, ms) => () => {}` - used by `transition:pulse` in templates. */
-declare var __rosefdTransitions: Record<string, (el: HTMLElement, duration: number) => () => void>;
+/** Named view transitions: `globalThis.__rosefcTransitions.pulse = (el, ms) => () => {}` - used by `transition:pulse` in templates. */
+declare var __rosefcTransitions: Record<string, (el: HTMLElement, duration: number) => () => void>;
 
 
 declare function redirect(path: string, status?: 301 | 302 | 303 | 307 | 308): never;
@@ -198,7 +198,7 @@ interface UDPSocket {
 }
 
 /**
- * Listen for UDP datagrams (LoRa gateways, sensor feeds) from inside a Rosefd
+ * Listen for UDP datagrams (LoRa gateways, sensor feeds) from inside a Rosefc
  * app. Only registers the spec; the framework binds it at serve-worker boot, so
  * a build/prerender never opens a socket.
  */