@tinyfx/runtime 0.1.9 → 0.2.0

package/dist/__tests__/http-errors.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/http-errors.test.js

@@ -0,0 +1,65 @@
+import { describe, it, expect } from "vitest";
+import { httpError, timeoutError, parseError } from "../http/data";
+describe("httpError", () => {
+    it("creates http error with all fields", () => {
+        const err = httpError(404, "Not Found", "/api/test", "GET");
+        expect(err.kind).toBe("http");
+        if (err.kind === "http") {
+            expect(err.status).toBe(404);
+            expect(err.statusText).toBe("Not Found");
+            expect(err.url).toBe("/api/test");
+            expect(err.method).toBe("GET");
+        }
+    });
+    it("includes optional response", () => {
+        const response = new Response();
+        const err = httpError(500, "Server Error", "/api", "POST", response);
+        if (err.kind === "http") {
+            expect(err.response).toBe(response);
+        }
+    });
+});
+describe("timeoutError", () => {
+    it("creates timeout error with url and timeout", () => {
+        const err = timeoutError("/api/slow", 5000);
+        expect(err.kind).toBe("timeout");
+        if (err.kind === "timeout") {
+            expect(err.url).toBe("/api/slow");
+            expect(err.timeout).toBe(5000);
+        }
+    });
+});
+describe("parseError", () => {
+    it("creates parse error with message and url", () => {
+        const err = parseError("Unexpected token", "/api/json");
+        expect(err.kind).toBe("parse");
+        if (err.kind === "parse") {
+            expect(err.message).toBe("Unexpected token");
+            expect(err.url).toBe("/api/json");
+        }
+    });
+});
+describe("error discrimination", () => {
+    it("allows discriminating by kind", () => {
+        const errors = [
+            httpError(400, "Bad Request", "/a", "GET"),
+            timeoutError("/b", 1000),
+            parseError("Bad JSON", "/c"),
+        ];
+        const httpErr = errors.find((e) => e.kind === "http");
+        expect(httpErr === null || httpErr === void 0 ? void 0 : httpErr.kind).toBe("http");
+        if ((httpErr === null || httpErr === void 0 ? void 0 : httpErr.kind) === "http") {
+            expect(httpErr.status).toBe(400);
+        }
+        const timeoutErr = errors.find((e) => e.kind === "timeout");
+        expect(timeoutErr === null || timeoutErr === void 0 ? void 0 : timeoutErr.kind).toBe("timeout");
+        if ((timeoutErr === null || timeoutErr === void 0 ? void 0 : timeoutErr.kind) === "timeout") {
+            expect(timeoutErr.timeout).toBe(1000);
+        }
+        const parseErr = errors.find((e) => e.kind === "parse");
+        expect(parseErr === null || parseErr === void 0 ? void 0 : parseErr.kind).toBe("parse");
+        if ((parseErr === null || parseErr === void 0 ? void 0 : parseErr.kind) === "parse") {
+            expect(parseErr.message).toBe("Bad JSON");
+        }
+    });
+});

package/dist/__tests__/router-merged.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/router-merged.test.js

@@ -0,0 +1,33 @@
+import { describe, it, expect, vi } from "vitest";
+import { navigate, goBack } from "../router/index";
+describe("navigate", () => {
+    it("is a function that accepts a path string", () => {
+        expect(typeof navigate).toBe("function");
+        expect(() => navigate("/test/path")).not.toThrow();
+    });
+});
+describe("goBack", () => {
+    it("calls history.go(-1)", () => {
+        const spy = vi.spyOn(window.history, "go");
+        goBack();
+        expect(spy).toHaveBeenCalledWith(-1);
+        spy.mockRestore();
+    });
+});
+describe("RouteMeta type", () => {
+    it("accepts valid route metadata", () => {
+        const meta = { page: "blog-post", path: "/blog/:slug" };
+        expect(meta.page).toBe("blog-post");
+        expect(meta.path).toBe("/blog/:slug");
+    });
+});
+describe("RouteMap type", () => {
+    it("accepts route map object", () => {
+        const routes = {
+            "/": { page: "index", path: "/" },
+            "/blog/:slug": { page: "blog-post", path: "/blog/:slug" },
+        };
+        expect(Object.keys(routes)).toHaveLength(2);
+        expect(routes["/blog/:slug"].page).toBe("blog-post");
+    });
+});

package/dist/__tests__/signals.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/signals.test.js

@@ -0,0 +1,93 @@
+import { describe, it, expect } from "vitest";
+import { signal, effect } from "../signals";
+describe("signal (inlined)", () => {
+    it("returns current value when called", () => {
+        const count = signal(0);
+        expect(count()).toBe(0);
+    });
+    it("updates value via set()", () => {
+        const count = signal(0);
+        count.set(5);
+        expect(count()).toBe(5);
+    });
+    it("does not notify subscribers when value is the same", () => {
+        const count = signal(0);
+        let runs = 0;
+        effect(() => {
+            count();
+            runs++;
+        });
+        expect(runs).toBe(1);
+        count.set(0);
+        expect(runs).toBe(1);
+    });
+    it("notifies subscribers on change", () => {
+        const count = signal(0);
+        let value = 0;
+        effect(() => {
+            value = count();
+        });
+        expect(value).toBe(0);
+        count.set(10);
+        expect(value).toBe(10);
+    });
+    it("supports multiple subscribers", () => {
+        const count = signal(0);
+        let a = 0;
+        let b = 0;
+        effect(() => { a = count(); });
+        effect(() => { b = count() * 2; });
+        count.set(3);
+        expect(a).toBe(3);
+        expect(b).toBe(6);
+    });
+    it("works with objects", () => {
+        const user = signal({ name: "Alice" });
+        expect(user().name).toBe("Alice");
+        user.set({ name: "Bob" });
+        expect(user().name).toBe("Bob");
+    });
+    it("does not re-run effect when unrelated signal changes", () => {
+        const a = signal(0);
+        const b = signal(0);
+        let runs = 0;
+        effect(() => {
+            a();
+            runs++;
+        });
+        expect(runs).toBe(1);
+        b.set(1);
+        expect(runs).toBe(1);
+    });
+});
+describe("effect", () => {
+    it("runs immediately on creation", () => {
+        let ran = false;
+        effect(() => { ran = true; });
+        expect(ran).toBe(true);
+    });
+    it("re-runs when tracked signal changes", () => {
+        const count = signal(0);
+        let runs = 0;
+        effect(() => {
+            count();
+            runs++;
+        });
+        expect(runs).toBe(1);
+        count.set(1);
+        expect(runs).toBe(2);
+    });
+    it("supports nested signal reads", () => {
+        const a = signal(1);
+        const b = signal(2);
+        let sum = 0;
+        effect(() => {
+            sum = a() + b();
+        });
+        expect(sum).toBe(3);
+        a.set(10);
+        expect(sum).toBe(12);
+        b.set(5);
+        expect(sum).toBe(15);
+    });
+});

package/dist/http/data.d.ts

@@ -1,56 +1,47 @@
 /**
- * Error thrown for non-success HTTP responses.
+ * Discriminated union type for HTTP errors.
  *
  * @example
  * try {
  *   await http.get("/posts");
  * } catch (error) {
- *   if (error instanceof HttpError) {
+ *   if (error.kind === "http") {
  *     console.error(error.status, error.url);
- *   }
- * }
- */
-export declare class HttpError extends Error {
-    readonly status: number;
-    readonly statusText: string;
-    readonly url: string;
-    readonly method: string;
-    readonly response?: Response | undefined;
-    constructor(status: number, statusText: string, url: string, method: string, response?: Response | undefined);
-}
-/**
- * Error thrown when a request times out.
- *
- * @example
- * try {
- *   await http.get("/slow", { timeout: 100 });
- * } catch (error) {
- *   if (error instanceof HttpTimeoutError) {
+ *   } else if (error.kind === "timeout") {
  *     console.error(error.timeout);
- *   }
- * }
- */
-export declare class HttpTimeoutError extends Error {
-    readonly url: string;
-    readonly timeout: number;
-    constructor(url: string, timeout: number);
-}
-/**
- * Error thrown when a JSON response cannot be parsed.
- *
- * @example
- * try {
- *   await http.get("/broken-json");
- * } catch (error) {
- *   if (error instanceof HttpParseError) {
+ *   } else if (error.kind === "parse") {
  *     console.error(error.url);
  *   }
  * }
  */
-export declare class HttpParseError extends Error {
-    readonly url: string;
-    constructor(message: string, url: string);
-}
+export type HttpError = {
+    kind: "http";
+    status: number;
+    statusText: string;
+    url: string;
+    method: string;
+    response?: Response;
+} | {
+    kind: "timeout";
+    url: string;
+    timeout: number;
+} | {
+    kind: "parse";
+    message: string;
+    url: string;
+};
+export declare function httpError(status: number, statusText: string, url: string, method: string, response?: Response): HttpError;
+export declare function timeoutError(url: string, timeout: number): HttpError;
+export declare function parseError(message: string, url: string): HttpError;
+export declare function isHttpError(err: unknown): err is Extract<HttpError, {
+    kind: "http";
+}>;
+export declare function isTimeoutError(err: unknown): err is Extract<HttpError, {
+    kind: "timeout";
+}>;
+export declare function isParseError(err: unknown): err is Extract<HttpError, {
+    kind: "parse";
+}>;
 /**
  * Hook that can rewrite an outgoing request before `fetch` runs.
  *

package/dist/http/data.js

@@ -1,62 +1,18 @@
-/**
- * Error thrown for non-success HTTP responses.
- *
- * @example
- * try {
- *   await http.get("/posts");
- * } catch (error) {
- *   if (error instanceof HttpError) {
- *     console.error(error.status, error.url);
- *   }
- * }
- */
-export class HttpError extends Error {
-    constructor(status, statusText, url, method, response) {
-        super(`HTTP ${status} ${statusText}: ${method} ${url}`);
-        this.status = status;
-        this.statusText = statusText;
-        this.url = url;
-        this.method = method;
-        this.response = response;
-        this.name = "HttpError";
-    }
+export function httpError(status, statusText, url, method, response) {
+    return { kind: "http", status, statusText, url, method, response };
 }
-/**
- * Error thrown when a request times out.
- *
- * @example
- * try {
- *   await http.get("/slow", { timeout: 100 });
- * } catch (error) {
- *   if (error instanceof HttpTimeoutError) {
- *     console.error(error.timeout);
- *   }
- * }
- */
-export class HttpTimeoutError extends Error {
-    constructor(url, timeout) {
-        super(`Request timeout after ${timeout}ms: ${url}`);
-        this.url = url;
-        this.timeout = timeout;
-        this.name = "HttpTimeoutError";
-    }
+export function timeoutError(url, timeout) {
+    return { kind: "timeout", url, timeout };
 }
-/**
- * Error thrown when a JSON response cannot be parsed.
- *
- * @example
- * try {
- *   await http.get("/broken-json");
- * } catch (error) {
- *   if (error instanceof HttpParseError) {
- *     console.error(error.url);
- *   }
- * }
- */
-export class HttpParseError extends Error {
-    constructor(message, url) {
-        super(message);
-        this.url = url;
-        this.name = "HttpParseError";
-    }
+export function parseError(message, url) {
+    return { kind: "parse", message, url };
+}
+export function isHttpError(err) {
+    return typeof err === "object" && err !== null && "kind" in err && err.kind === "http";
+}
+export function isTimeoutError(err) {
+    return typeof err === "object" && err !== null && "kind" in err && err.kind === "timeout";
+}
+export function isParseError(err) {
+    return typeof err === "object" && err !== null && "kind" in err && err.kind === "parse";
 }

package/dist/http/http.js

@@ -1,6 +1,6 @@
 // @tinyfx/runtime — HTTP client
 // Thin, typed wrapper over fetch.
-import { HttpError, HttpParseError, HttpTimeoutError } from "./data";
+import { httpError, timeoutError, parseError, isHttpError } from "./data";
 import { buildUrl, sleep } from "./helper";
 /**
  * Creates a typed HTTP client around `fetch`.
@@ -73,7 +73,7 @@ export function createHttp(config = {}) {
                         if ((_b = options.signal) === null || _b === void 0 ? void 0 : _b.aborted) {
                             throw err; // User cancelled
                         }
-                        throw new HttpTimeoutError(requestUrl, timeoutMs);
+                        throw timeoutError(requestUrl, timeoutMs);
                     }
                     throw err;
                 }
@@ -85,7 +85,7 @@ export function createHttp(config = {}) {
                     res = await interceptor(res);
                 }
                 if (!res.ok) {
-                    throw new HttpError(res.status, res.statusText, requestUrl, method, res);
+                    throw httpError(res.status, res.statusText, requestUrl, method, res);
                 }
                 // Parse response based on content type
                 const contentType = res.headers.get("content-type") || "";
@@ -98,7 +98,7 @@ export function createHttp(config = {}) {
                         return JSON.parse(text);
                     }
                     catch (err) {
-                        throw new HttpParseError(`Failed to parse JSON response: ${err instanceof Error ? err.message : "Unknown error"}`, requestUrl);
+                        throw parseError(`Failed to parse JSON response: ${err instanceof Error ? err.message : "Unknown error"}`, requestUrl);
                     }
                 }
                 if (contentType.includes("text/")) {
@@ -115,8 +115,8 @@ export function createHttp(config = {}) {
             }
             catch (err) {
                 // Retry logic for network errors or 5xx errors
-                const shouldRetry = attempts < maxAttempts &&
-                    (!(err instanceof HttpError) || (err.status >= 500 && err.status < 600));
+                const is5xx = isHttpError(err) && err.status >= 500 && err.status < 600;
+                const shouldRetry = attempts < maxAttempts && (!isHttpError(err) || is5xx);
                 if (shouldRetry) {
                     await sleep(retryDelay * attempts);
                     continue;

package/dist/index.d.ts

@@ -9,7 +9,7 @@ export { matchPath, splitPath } from "./router/path-matcher";
 export type { RouteDef } from "./router/path-matcher";
 export { init } from "./init";
 export type { InitConfig } from "./init";
-export { initRouter, getParam, navigate, goBack } from "./router/index";
+export { getParam, getParams, navigate, goBack } from "./router/index";
 export { onMount, onDestroy } from "./router/lifecycle";
 export type { TinyFxContext } from "./context";
-export type { RouteMap, RouteMeta } from "./router/types";
+export type { RouteMap, RouteMeta } from "./router/index";

package/dist/index.js

@@ -10,5 +10,5 @@ export { markMounted, isMounted } from "./mount-state";
 export { matchPath, splitPath } from "./router/path-matcher";
 export { init } from "./init";
 // Keep existing router exports
-export { initRouter, getParam, navigate, goBack } from "./router/index";
+export { getParam, getParams, navigate, goBack } from "./router/index";
 export { onMount, onDestroy } from "./router/lifecycle";

package/dist/init.js

@@ -3,7 +3,8 @@
 import { matchPath, splitPath } from "./router/path-matcher";
 import { initLifecycle } from "./router/lifecycle";
 import { highlightActiveLinks } from "./router/active-links";
-import { navigate } from "./router/navigate";
+import { navigate } from "./router/index";
+import { setParams } from "./router/params";
 import { mountComponents } from "./registry";
 import { runPageInit } from "./page-registry";
 let initialized = false;
@@ -30,6 +31,7 @@ export function init(config) {
     }
     initLifecycle();
     highlightActiveLinks(pathname);
+    setParams(params);
     const ctx = { params, navigate };
     const instances = mountComponents(ctx);
     if (config.setupDirectives) {

package/dist/router/index.d.ts

@@ -1,25 +1,23 @@
-import type { RouteMap } from "./types";
-import { navigate, goBack } from "./navigate";
-import { getParam } from "./params";
-export type { RouteMap };
-export { navigate, goBack, getParam };
 /**
- * Initialise the TinyFX router for the current page.
- *
- * Called automatically from the compiler-generated `tinyfx.gen.ts` on every
- * page load.  Matches `window.location.pathname` against the compiled route
- * map, resolves URL params, starts lifecycle hooks, and highlights active
- * navigation links.
- *
- * @param routes - The route map emitted by `tinyfx build`.
- * @returns Nothing
- *
- * @example
- * // tinyfx.gen.ts (auto-generated — do not edit)
- * initRouter({
- *   "/":          { page: "home",      path: "/" },
- *   "/blog":      { page: "blog",      path: "/blog" },
- *   "/blog/:slug":{ page: "blog-post", path: "/blog/:slug" },
- * });
+ * Metadata for a single route produced by the compiler.
  */
-export declare function initRouter(routes: RouteMap): void;
+export interface RouteMeta {
+    /** The page name, derived from the source filename. */
+    page: string;
+    /** The declared URL pattern, e.g. "/blog/:slug". */
+    path: string;
+}
+/**
+ * The full route map emitted by `tinyfx build` into `tinyfx.gen.ts`.
+ */
+export type RouteMap = Record<string, RouteMeta>;
+/**
+ * Navigate to the given path.
+ * This is a full browser navigation — not a DOM swap.
+ */
+export declare function navigate(path: string): void;
+/**
+ * Go back one step in the browser history.
+ */
+export declare function goBack(): void;
+export { getParam, getParams } from "./params";

package/dist/router/index.js

@@ -1,39 +1,15 @@
-// @tinyfx/runtime — router entry point
-import { navigate, goBack } from "./navigate";
-import { getParam, resolveParams } from "./params";
-import { initLifecycle } from "./lifecycle";
-import { highlightActiveLinks } from "./active-links";
-export { navigate, goBack, getParam };
+// @tinyfx/runtime — router utilities
 /**
- * Initialise the TinyFX router for the current page.
- *
- * Called automatically from the compiler-generated `tinyfx.gen.ts` on every
- * page load.  Matches `window.location.pathname` against the compiled route
- * map, resolves URL params, starts lifecycle hooks, and highlights active
- * navigation links.
- *
- * @param routes - The route map emitted by `tinyfx build`.
- * @returns Nothing
- *
- * @example
- * // tinyfx.gen.ts (auto-generated — do not edit)
- * initRouter({
- *   "/":          { page: "home",      path: "/" },
- *   "/blog":      { page: "blog",      path: "/blog" },
- *   "/blog/:slug":{ page: "blog-post", path: "/blog/:slug" },
- * });
+ * Navigate to the given path.
+ * This is a full browser navigation — not a DOM swap.
  */
-export function initRouter(routes) {
-    const pathname = window.location.pathname;
-    for (const pattern of Object.keys(routes)) {
-        if (resolveParams(pattern, pathname)) {
-            // Match found
-            initLifecycle();
-            highlightActiveLinks(pathname);
-            return;
-        }
-    }
-    // No route matched — log a warning and do nothing else.
-    console.warn(`[tinyfx] No route matched for pathname: "${pathname}". ` +
-        "Check that a page file exists for this URL in src/pages/.");
+export function navigate(path) {
+    window.location.href = path;
 }
+/**
+ * Go back one step in the browser history.
+ */
+export function goBack() {
+    window.history.go(-1);
+}
+export { getParam, getParams } from "./params";

package/dist/router/lifecycle.d.ts

@@ -29,7 +29,7 @@ export declare function onMount(fn: LifecycleCallback): void;
 export declare function onDestroy(fn: LifecycleCallback): void;
 /**
  * Trigger all registered `onMount` callbacks.
- * Called by `initRouter` after matching the current route.
+ * Called by `init()` after matching the current route.
  *
  * @returns Nothing
  *
@@ -39,7 +39,7 @@ export declare function onDestroy(fn: LifecycleCallback): void;
 export declare function flushMount(): void;
 /**
  * Wire up registered `onDestroy` callbacks to the `pagehide` event.
- * Called by `initRouter` after matching the current route.
+ * Called by `init()` after matching the current route.
  *
  * @returns Nothing
  *

package/dist/router/lifecycle.js

@@ -39,7 +39,7 @@ export function onDestroy(fn) {
 }
 /**
  * Trigger all registered `onMount` callbacks.
- * Called by `initRouter` after matching the current route.
+ * Called by `init()` after matching the current route.
  *
  * @returns Nothing
  *
@@ -57,7 +57,7 @@ export function flushMount() {
 }
 /**
  * Wire up registered `onDestroy` callbacks to the `pagehide` event.
- * Called by `initRouter` after matching the current route.
+ * Called by `init()` after matching the current route.
  *
  * @returns Nothing
  *

package/dist/router/params.d.ts

@@ -1,20 +1,9 @@
 /**
- * Match `pattern` (e.g. "/blog/:slug") against `pathname` (e.g. "/blog/hello").
+ * Set resolved route params (called internally by init()).
  *
- * Returns true if they match, and stores any `:param` captures in the
- * module-level store so `getParam()` can retrieve them.
- *
- * Static segments must match exactly; `:param` segments match any non-empty
- * path segment.
- *
- * @param pattern - The route pattern produced by the compiler
- * @param pathname - The current browser pathname
- * @returns `true` when the pathname matches the pattern, otherwise `false`
- *
- * @example
- * resolveParams("/blog/:slug", "/blog/hello-world");
+ * @param params - The resolved URL parameters
  */
-export declare function resolveParams(pattern: string, pathname: string): boolean;
+export declare function setParams(params: Record<string, string>): void;
 /**
  * Retrieve a URL parameter resolved for the current page.
  *

package/dist/router/params.js

@@ -2,40 +2,12 @@
 /** Module-level store for the current page's resolved params. */
 let currentParams = {};
 /**
- * Match `pattern` (e.g. "/blog/:slug") against `pathname` (e.g. "/blog/hello").
+ * Set resolved route params (called internally by init()).
  *
- * Returns true if they match, and stores any `:param` captures in the
- * module-level store so `getParam()` can retrieve them.
- *
- * Static segments must match exactly; `:param` segments match any non-empty
- * path segment.
- *
- * @param pattern - The route pattern produced by the compiler
- * @param pathname - The current browser pathname
- * @returns `true` when the pathname matches the pattern, otherwise `false`
- *
- * @example
- * resolveParams("/blog/:slug", "/blog/hello-world");
+ * @param params - The resolved URL parameters
  */
-export function resolveParams(pattern, pathname) {
-    const patternParts = pattern.split("/").filter(Boolean);
-    const pathParts = pathname.split("/").filter(Boolean);
-    if (patternParts.length !== pathParts.length)
-        return false;
-    const captured = {};
-    for (let i = 0; i < patternParts.length; i++) {
-        const seg = patternParts[i];
-        if (seg.startsWith(":")) {
-            // Dynamic segment — capture the value
-            captured[seg.slice(1)] = decodeURIComponent(pathParts[i]);
-        }
-        else if (seg !== pathParts[i]) {
-            // Static segment mismatch
-            return false;
-        }
-    }
-    currentParams = captured;
-    return true;
+export function setParams(params) {
+    currentParams = params;
 }
 /**
  * Retrieve a URL parameter resolved for the current page.

package/dist/signals.d.ts

@@ -1,23 +1,3 @@
-/**
- * Reactive value container used by TinyFX signals.
- *
- * Reading the value through {@link Signal.get} during an active effect records
- * that effect as a subscriber. Writing through {@link Signal.set} re-runs the
- * affected subscribers.
- *
- * @example
- * const count = new Signal(0);
- * console.log(count.get());
- * count.set(1);
- * console.log(count.get());
- */
-export declare class Signal<T> {
-    private value;
-    private subs;
-    constructor(v: T);
-    get(): T;
-    set(v: T): void;
-}
 /**
  * Creates a reactive signal function.
  *

package/dist/signals.js

@@ -1,38 +1,6 @@
 // @tinyfx/runtime — signals
 // Minimal, explicit reactivity — no proxies, no magic.
 const effectStack = [];
-/**
- * Reactive value container used by TinyFX signals.
- *
- * Reading the value through {@link Signal.get} during an active effect records
- * that effect as a subscriber. Writing through {@link Signal.set} re-runs the
- * affected subscribers.
- *
- * @example
- * const count = new Signal(0);
- * console.log(count.get());
- * count.set(1);
- * console.log(count.get());
- */
-export class Signal {
-    constructor(v) {
-        this.subs = new Set();
-        this.value = v;
-    }
-    get() {
-        const running = effectStack[effectStack.length - 1];
-        if (running) {
-            this.subs.add(running);
-        }
-        return this.value;
-    }
-    set(v) {
-        if (Object.is(v, this.value))
-            return;
-        this.value = v;
-        this.subs.forEach((fn) => fn());
-    }
-}
 /**
  * Creates a reactive signal function.
  *
@@ -46,9 +14,20 @@ export class Signal {
  * count.set(1);
  */
 export function signal(v) {
-    const s = new Signal(v);
-    const fn = () => s.get();
-    fn.set = (v) => s.set(v);
+    let value = v;
+    const subs = new Set();
+    const fn = () => {
+        const running = effectStack[effectStack.length - 1];
+        if (running)
+            subs.add(running);
+        return value;
+    };
+    fn.set = (next) => {
+        if (Object.is(next, value))
+            return;
+        value = next;
+        subs.forEach((s) => s());
+    };
     return fn;
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tinyfx/runtime",
-  "version": "0.1.9",
+  "version": "0.2.0",
   "description": "Minimal frontend runtime — signals, DOM helpers, typed HTTP, DTO mapping",
   "type": "module",
   "main": "./dist/index.js",