@fluixi/core 1.0.0-alpha.100

package/dist/src/lib/isomorphic.cjs

@@ -0,0 +1,90 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/isomorphic.ts
+var isomorphic_exports = {};
+__export(isomorphic_exports, {
+  createIsomorphicState: () => createIsomorphicState,
+  createIsomorphicStore: () => createIsomorphicStore
+});
+module.exports = __toCommonJS(isomorphic_exports);
+var import_signal = require("@fluixi/reactive/signal");
+var import_dom = require("@fluixi/dom");
+var import_storage = require("@fluixi/storage");
+var import_browser = require("@fluixi/storage/browser");
+var REGISTRY_KEY = "__fluixi_iso_states__";
+var SEED_PREFIX = "__iso:";
+function registry() {
+  return globalThis[REGISTRY_KEY] ??= /* @__PURE__ */ new Map();
+}
+function readSeed(key) {
+  if (typeof window === "undefined") return void 0;
+  const data = (0, import_dom.getServerData)();
+  return data ? data[SEED_PREFIX + key] : void 0;
+}
+function createIsomorphicState(key, options) {
+  const seed = readSeed(key);
+  const initial = seed !== void 0 ? seed : typeof window !== "undefined" && options.client ? options.client() : options.fallback;
+  const [value, set] = (0, import_signal.createSignal)(initial, { name: key });
+  registry().set(key, { server: options.server, set });
+  return { value, set, key };
+}
+function createIsomorphicStore(key, options) {
+  const seeded = readSeed(key) !== void 0;
+  const base = createIsomorphicState(key, {
+    server: options.server,
+    fallback: options.fallback
+  });
+  const value = () => base.value() ?? options.fallback;
+  const persistWrite = (v) => {
+    const target = options.persist;
+    if (!target) return;
+    if (typeof target === "string" && typeof window === "undefined") return;
+    try {
+      const { storage, key: key2 } = typeof target === "string" ? { storage: (0, import_storage.createSyncStorage)({ adapter: (0, import_browser.localStorageAdapter)() }), key: target } : target;
+      storage.set(key2, v);
+    } catch {
+    }
+  };
+  const set = (v) => {
+    base.set(v);
+    persistWrite(v);
+  };
+  const setField = (k, val) => {
+    set({ ...value(), [k]: val });
+  };
+  const fields = {};
+  for (const k of Object.keys(options.fallback)) {
+    fields[k] = (0, import_signal.createMemo)(() => value()[k], void 0, { name: `${key}.${String(k)}` });
+  }
+  let initPromise = null;
+  const ensureInit = () => {
+    if (seeded || !options.client) return Promise.resolve();
+    if (!initPromise) {
+      initPromise = Promise.resolve(options.client()).then((v) => {
+        set(v);
+      }).catch((e) => {
+        initPromise = null;
+        throw e;
+      });
+    }
+    return initPromise;
+  };
+  return { value, fields, set, setField, ensureInit, key, seeded };
+}

package/dist/src/lib/isomorphic.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Isomorphic request state, the generic form of "ensureInit + transfer".
+ *
+ * A value that is resolved ONCE on the server (per request, before the app renders),
+ * serialized into the page, and seeded SYNCHRONOUSLY on the client so the first client
+ * render matches the server (no hydration mismatch) and nothing refetches.
+ *
+ * - Server: @fluixi/server's `preloadServerState(event)` walks the registry below,
+ *   runs each `server(event)` resolver, sets the signal, and stashes the value for
+ *   serialization (it lands in `window.__FX_DATA__['__iso:<key>']`).
+ * - Client: `createIsomorphicState` reads that seed at creation and starts there.
+ *
+ * This module is client-safe (no node imports) so app stores can call it on both sides.
+ * It talks to @fluixi/server only through a `globalThis` registry, no import edge.
+ *
+ * NOTE (prototype): the signal is module-scoped, so concurrent SSR requests share it.
+ * That is fine for a single default value; per-user, per-request isolation wants the
+ * request-scoped (AsyncLocalStorage) store, a follow-up.
+ */
+import { type Accessor } from '@fluixi/reactive/signal';
+import { type TypedStorage } from '@fluixi/storage';
+export interface IsomorphicState<T> {
+    /** Reactive accessor for the current value (a real signal: safe in JSX/control flow). */
+    value: Accessor<T | undefined>;
+    /** Update the value (client-side preference changes, optimistic updates). */
+    set: (v: T | undefined) => void;
+    /** Stable serialization key. */
+    key: string;
+}
+export interface IsomorphicOptions<T> {
+    /** Resolve the value on the server for this request (receives the RequestEvent). */
+    server: (event: any) => T | Promise<T>;
+    /** Optional client-only initial value when there is no server seed (pure SPA load). */
+    client?: () => T | undefined;
+    /** Value before resolution. */
+    fallback?: T;
+}
+/**
+ * A value resolved on the server, transferred to the client, and resolvable there too.
+ *
+ * The server resolver runs per request and its result is serialized into the page, so the
+ * client starts with the answer rather than fetching it again. On a cold client load with
+ * no seed, the client resolver runs once instead.
+ *
+ * `key` names the transfer slot and has to be stable across the two sides.
+ *
+ * @example
+ * ```ts
+ * const user = createIsomorphicState('user', {
+ *   server: (event) => event.locals.user,
+ *   client: () => fetch('/api/me').then((r) => r.json()),
+ * });
+ * ```
+ */
+export declare function createIsomorphicState<T>(key: string, options: IsomorphicOptions<T>): IsomorphicState<T>;
+export interface IsomorphicStore<T extends Record<string, any>> {
+    /** Reactive accessor for the whole record (always defined: falls back to `fallback`). */
+    value: Accessor<T>;
+    /** Per-field reactive accessors, one for every key of `fallback`. */
+    fields: {
+        [K in keyof T]: Accessor<T[K]>;
+    };
+    /** Replace the whole record. */
+    set: (v: T) => void;
+    /** Update ONE field, preserving the rest. */
+    setField: <K extends keyof T>(key: K, val: T[K]) => void;
+    /**
+     * Run the async `client` resolver exactly once (memoised; the promise is reset on
+     * failure so a later call can retry). A no-op when the value was server-seeded, the
+     * server already resolved and transferred it, so there is nothing to fetch.
+     */
+    ensureInit: () => Promise<void>;
+    /** Stable serialization key. */
+    key: string;
+    /**
+     * Whether the server rendered this value and sent it with the page. Tells "the server
+     * said nobody" apart from "no server said anything" (a client-only load).
+     */
+    readonly seeded: boolean;
+}
+export interface IsomorphicStoreOptions<T> {
+    /** Resolve the record on the server for this request (receives the RequestEvent). */
+    server: (event: any) => T | Promise<T>;
+    /** Resolve the record on a pure-SPA cold load (no server seed). Run once by ensureInit(). */
+    client?: () => T | Promise<T>;
+    /** Value before resolution / the per-field accessor key set. Required for a store. */
+    fallback: T;
+    /**
+     * Mirror the record into storage on every write: a key in localStorage, or a key in a
+     * storage of your own (`useStorage({ scope: 'cookie' })` to have the server see it too).
+     */
+    persist?: string | {
+        storage: TypedStorage<any>;
+        key: string;
+    };
+}
+/**
+ * `createIsomorphicState` for a record, exposed as a store rather than a single value.
+ *
+ * Reads track per key, so a component using one field is untouched when another changes.
+ * Otherwise the transfer is the same: the server resolver runs per request, the result is
+ * serialized into the page, and a seeded client does not refetch.
+ *
+ * @example
+ * ```ts
+ * const settings = createIsomorphicStore('settings', {
+ *   server: (event) => loadSettings(event.locals.userId),
+ *   client: () => fetch('/api/settings').then((r) => r.json()),
+ * });
+ * settings.state.theme;   // tracks `theme` alone
+ * ```
+ */
+export declare function createIsomorphicStore<T extends Record<string, any>>(key: string, options: IsomorphicStoreOptions<T>): IsomorphicStore<T>;
+//# sourceMappingURL=isomorphic.d.ts.map

package/dist/src/lib/isomorphic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isomorphic.d.ts","sourceRoot":"","sources":["../../../src/lib/isomorphic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAA4B,KAAK,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAElF,OAAO,EAAqB,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAevE,MAAM,WAAW,eAAe,CAAC,CAAC;IAChC,yFAAyF;IACzF,KAAK,EAAE,QAAQ,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;IAC/B,6EAA6E;IAC7E,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,SAAS,KAAK,IAAI,CAAC;IAChC,gCAAgC;IAChC,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,iBAAiB,CAAC,CAAC;IAClC,oFAAoF;IACpF,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IACvC,uFAAuF;IACvF,MAAM,CAAC,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IAC7B,+BAA+B;IAC/B,QAAQ,CAAC,EAAE,CAAC,CAAC;CACd;AASD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EACrC,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAC5B,eAAe,CAAC,CAAC,CAAC,CAapB;AAkBD,MAAM,WAAW,eAAe,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAC5D,yFAAyF;IACzF,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;IACnB,qEAAqE;IACrE,MAAM,EAAE;SAAG,CAAC,IAAI,MAAM,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;KAAE,CAAC;IAC3C,gCAAgC;IAChC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI,CAAC;IACpB,6CAA6C;IAC7C,QAAQ,EAAE,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;IACzD;;;;OAIG;IACH,UAAU,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAChC,gCAAgC;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,sBAAsB,CAAC,CAAC;IACvC,qFAAqF;IACrF,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IACvC,6FAA6F;IAC7F,MAAM,CAAC,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAC9B,sFAAsF;IACtF,QAAQ,EAAE,CAAC,CAAC;IACZ;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG;QAAE,OAAO,EAAE,YAAY,CAAC,GAAG,CAAC,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;CAChE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACjE,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,sBAAsB,CAAC,CAAC,CAAC,GACjC,eAAe,CAAC,CAAC,CAAC,CAuDpB"}

package/dist/src/lib/isomorphic.js

@@ -0,0 +1,132 @@
+/**
+ * Isomorphic request state, the generic form of "ensureInit + transfer".
+ *
+ * A value that is resolved ONCE on the server (per request, before the app renders),
+ * serialized into the page, and seeded SYNCHRONOUSLY on the client so the first client
+ * render matches the server (no hydration mismatch) and nothing refetches.
+ *
+ * - Server: @fluixi/server's `preloadServerState(event)` walks the registry below,
+ *   runs each `server(event)` resolver, sets the signal, and stashes the value for
+ *   serialization (it lands in `window.__FX_DATA__['__iso:<key>']`).
+ * - Client: `createIsomorphicState` reads that seed at creation and starts there.
+ *
+ * This module is client-safe (no node imports) so app stores can call it on both sides.
+ * It talks to @fluixi/server only through a `globalThis` registry, no import edge.
+ *
+ * NOTE (prototype): the signal is module-scoped, so concurrent SSR requests share it.
+ * That is fine for a single default value; per-user, per-request isolation wants the
+ * request-scoped (AsyncLocalStorage) store, a follow-up.
+ */
+import { createSignal, createMemo } from '@fluixi/reactive/signal';
+import { getServerData } from '@fluixi/dom';
+import { createSyncStorage } from '@fluixi/storage';
+import { localStorageAdapter } from '@fluixi/storage/browser';
+const REGISTRY_KEY = '__fluixi_iso_states__';
+const SEED_PREFIX = '__iso:';
+function registry() {
+    return (globalThis[REGISTRY_KEY] ??= new Map());
+}
+/** The server seed for `key`, if the page was server-rendered. */
+function readSeed(key) {
+    if (typeof window === 'undefined')
+        return undefined;
+    const data = getServerData();
+    return data ? data[SEED_PREFIX + key] : undefined;
+}
+/**
+ * A value resolved on the server, transferred to the client, and resolvable there too.
+ *
+ * The server resolver runs per request and its result is serialized into the page, so the
+ * client starts with the answer rather than fetching it again. On a cold client load with
+ * no seed, the client resolver runs once instead.
+ *
+ * `key` names the transfer slot and has to be stable across the two sides.
+ *
+ * @example
+ * ```ts
+ * const user = createIsomorphicState('user', {
+ *   server: (event) => event.locals.user,
+ *   client: () => fetch('/api/me').then((r) => r.json()),
+ * });
+ * ```
+ */
+export function createIsomorphicState(key, options) {
+    const seed = readSeed(key);
+    const initial = seed !== undefined
+        ? seed
+        : typeof window !== 'undefined' && options.client
+            ? options.client()
+            : options.fallback;
+    const [value, set] = createSignal(initial, { name: key });
+    registry().set(key, { server: options.server, set: set });
+    return { value, set: set, key };
+}
+/**
+ * `createIsomorphicState` for a record, exposed as a store rather than a single value.
+ *
+ * Reads track per key, so a component using one field is untouched when another changes.
+ * Otherwise the transfer is the same: the server resolver runs per request, the result is
+ * serialized into the page, and a seeded client does not refetch.
+ *
+ * @example
+ * ```ts
+ * const settings = createIsomorphicStore('settings', {
+ *   server: (event) => loadSettings(event.locals.userId),
+ *   client: () => fetch('/api/settings').then((r) => r.json()),
+ * });
+ * settings.state.theme;   // tracks `theme` alone
+ * ```
+ */
+export function createIsomorphicStore(key, options) {
+    // Whether the server transferred a value for this key (read before the base state
+    // consumes the seed). When true, ensureInit() must not refetch on the client.
+    const seeded = readSeed(key) !== undefined;
+    const base = createIsomorphicState(key, {
+        server: options.server,
+        fallback: options.fallback,
+    });
+    const value = () => base.value() ?? options.fallback;
+    const persistWrite = (v) => {
+        const target = options.persist;
+        if (!target)
+            return;
+        if (typeof target === 'string' && typeof window === 'undefined')
+            return;
+        try {
+            const { storage, key } = typeof target === 'string' ? { storage: createSyncStorage({ adapter: localStorageAdapter() }), key: target } : target;
+            storage.set(key, v);
+        }
+        catch {
+            /* quota / private mode: persistence is best-effort */
+        }
+    };
+    const set = (v) => {
+        base.set(v);
+        persistWrite(v);
+    };
+    const setField = (k, val) => {
+        set({ ...value(), [k]: val });
+    };
+    const fields = {};
+    for (const k of Object.keys(options.fallback)) {
+        // Named for the devtools graph: `auth.user` rather than an anonymous memo.
+        fields[k] = createMemo(() => value()[k], undefined, { name: `${key}.${String(k)}` });
+    }
+    let initPromise = null;
+    const ensureInit = () => {
+        if (seeded || !options.client)
+            return Promise.resolve();
+        if (!initPromise) {
+            initPromise = Promise.resolve(options.client())
+                .then((v) => {
+                set(v);
+            })
+                .catch((e) => {
+                initPromise = null; // allow a retry on the next call
+                throw e;
+            });
+        }
+        return initPromise;
+    };
+    return { value, fields, set, setField, ensureInit, key, seeded };
+}

package/dist/src/lib/isomorphic.mjs

@@ -0,0 +1,69 @@
+// src/lib/isomorphic.ts
+import { createSignal, createMemo } from "@fluixi/reactive/signal";
+import { getServerData } from "@fluixi/dom";
+import { createSyncStorage } from "@fluixi/storage";
+import { localStorageAdapter } from "@fluixi/storage/browser";
+var REGISTRY_KEY = "__fluixi_iso_states__";
+var SEED_PREFIX = "__iso:";
+function registry() {
+  return globalThis[REGISTRY_KEY] ??= /* @__PURE__ */ new Map();
+}
+function readSeed(key) {
+  if (typeof window === "undefined") return void 0;
+  const data = getServerData();
+  return data ? data[SEED_PREFIX + key] : void 0;
+}
+function createIsomorphicState(key, options) {
+  const seed = readSeed(key);
+  const initial = seed !== void 0 ? seed : typeof window !== "undefined" && options.client ? options.client() : options.fallback;
+  const [value, set] = createSignal(initial, { name: key });
+  registry().set(key, { server: options.server, set });
+  return { value, set, key };
+}
+function createIsomorphicStore(key, options) {
+  const seeded = readSeed(key) !== void 0;
+  const base = createIsomorphicState(key, {
+    server: options.server,
+    fallback: options.fallback
+  });
+  const value = () => base.value() ?? options.fallback;
+  const persistWrite = (v) => {
+    const target = options.persist;
+    if (!target) return;
+    if (typeof target === "string" && typeof window === "undefined") return;
+    try {
+      const { storage, key: key2 } = typeof target === "string" ? { storage: createSyncStorage({ adapter: localStorageAdapter() }), key: target } : target;
+      storage.set(key2, v);
+    } catch {
+    }
+  };
+  const set = (v) => {
+    base.set(v);
+    persistWrite(v);
+  };
+  const setField = (k, val) => {
+    set({ ...value(), [k]: val });
+  };
+  const fields = {};
+  for (const k of Object.keys(options.fallback)) {
+    fields[k] = createMemo(() => value()[k], void 0, { name: `${key}.${String(k)}` });
+  }
+  let initPromise = null;
+  const ensureInit = () => {
+    if (seeded || !options.client) return Promise.resolve();
+    if (!initPromise) {
+      initPromise = Promise.resolve(options.client()).then((v) => {
+        set(v);
+      }).catch((e) => {
+        initPromise = null;
+        throw e;
+      });
+    }
+    return initPromise;
+  };
+  return { value, fields, set, setField, ensureInit, key, seeded };
+}
+export {
+  createIsomorphicState,
+  createIsomorphicStore
+};

package/dist/src/lib/jsx-runtime/index.cjs

@@ -0,0 +1,21 @@
+/*! @fluixi/core v1.0.0-alpha.100 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/jsx-runtime/index.ts
+var index_exports = {};
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("@fluixi/jsx/jsx-runtime"), module.exports);

package/dist/src/lib/jsx-runtime/index.d.ts

@@ -0,0 +1,13 @@
+export * from '@fluixi/jsx/jsx-runtime';
+export type { JSX } from '@fluixi/jsx';
+/**
+ * Global JSX namespace augmentation for "jsx": "preserve" mode.
+ *
+ * TypeScript with "jsx": "preserve" uses the global JSX namespace for element type
+ * checking (not jsxImportSource). This augmentation is applied automatically whenever
+ * any file imports from fluixi, because TypeScript processes declare global
+ * from all transitively-loaded modules.
+ *
+ * Pattern: same as SolidJS, the framework's main entry carries the global augmentation.
+ */
+//# sourceMappingURL=index.d.ts.map

package/dist/src/lib/jsx-runtime/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/jsx-runtime/index.ts"],"names":[],"mappings":"AAEA,cAAc,yBAAyB,CAAC;AAExC,YAAY,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AAEvC;;;;;;;;;GASG"}

package/dist/src/lib/jsx-runtime/index.js

@@ -0,0 +1,13 @@
+export * from '@fluixi/jsx/jsx-runtime';
+/**
+ * Global JSX namespace augmentation for "jsx": "preserve" mode.
+ *
+ * TypeScript with "jsx": "preserve" uses the global JSX namespace for element type
+ * checking (not jsxImportSource). This augmentation is applied automatically whenever
+ * any file imports from fluixi, because TypeScript processes declare global
+ * from all transitively-loaded modules.
+ *
+ * Pattern: same as SolidJS, the framework's main entry carries the global augmentation.
+ */
+// declare global {
+//   namespace JSX {

package/dist/src/lib/jsx-runtime/index.mjs

@@ -0,0 +1,4 @@
+/*! @fluixi/core v1.0.0-alpha.100 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+
+// src/lib/jsx-runtime/index.ts
+export * from "@fluixi/jsx/jsx-runtime";

package/dist/src/lib/jsx-runtime/jsx-dev-runtime.cjs

@@ -0,0 +1,21 @@
+/*! @fluixi/core v1.0.0-alpha.100 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/jsx-runtime/jsx-dev-runtime.ts
+var jsx_dev_runtime_exports = {};
+module.exports = __toCommonJS(jsx_dev_runtime_exports);
+__reExport(jsx_dev_runtime_exports, require("@fluixi/jsx/jsx-dev-runtime"), module.exports);

package/dist/src/lib/jsx-runtime/jsx-dev-runtime.d.ts

@@ -0,0 +1,2 @@
+export * from '@fluixi/jsx/jsx-dev-runtime';
+//# sourceMappingURL=jsx-dev-runtime.d.ts.map

package/dist/src/lib/jsx-runtime/jsx-dev-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsx-dev-runtime.d.ts","sourceRoot":"","sources":["../../../../src/lib/jsx-runtime/jsx-dev-runtime.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC"}

package/dist/src/lib/jsx-runtime/jsx-dev-runtime.js

@@ -0,0 +1 @@
+export * from '@fluixi/jsx/jsx-dev-runtime';

package/dist/src/lib/jsx-runtime/jsx-dev-runtime.mjs

@@ -0,0 +1,4 @@
+/*! @fluixi/core v1.0.0-alpha.100 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+
+// src/lib/jsx-runtime/jsx-dev-runtime.ts
+export * from "@fluixi/jsx/jsx-dev-runtime";