@lunora/svelte 0.0.0 → 1.0.0-alpha.1

package/dist/index.mjs

@@ -0,0 +1,10 @@
+export { auth } from './packem_shared/auth-D8EV6u02.mjs';
+export { connectionStatus } from './packem_shared/connectionStatus-CROr6jbn.mjs';
+export { getLunoraClient, setLunoraClient } from './packem_shared/setLunoraClient--bwSz7F6.mjs';
+export { hydratePreloaded } from './packem_shared/hydratePreloaded-BUv3k4-s.mjs';
+export { mutation } from './packem_shared/mutation-CA3qEPCB.mjs';
+export { infiniteQuery, paginatedQuery } from './packem_shared/paginatedQuery-CfCSITZv.mjs';
+export { presence } from './packem_shared/presence-Bf-y7QzR.mjs';
+export { query } from './packem_shared/query-B14VE2Qg.mjs';
+export { rateLimit } from './packem_shared/rateLimit-Cdw1kp8t.mjs';
+export { subscription } from './packem_shared/subscription-B3HDNcpq.mjs';

package/dist/packem_shared/auth-D8EV6u02.mjs

@@ -0,0 +1,28 @@
+import { getIdentityStore } from '@lunora/client/auth';
+import { readable } from 'svelte/store';
+import { getLunoraClient } from './setLunoraClient--bwSz7F6.mjs';
+
+const auth = (explicitClient) => {
+  const client = explicitClient ?? getLunoraClient();
+  const store = getIdentityStore(client);
+  const token = readable(client.getAuthToken(), (set) => {
+    set(client.getAuthToken());
+    const unsub = client.onAuthTokenChange((next) => {
+      set(next);
+    });
+    return unsub;
+  });
+  const user = readable(store.getUser(), (set) => {
+    set(store.getUser());
+    const unsub = store.subscribe(() => {
+      set(store.getUser());
+    });
+    return unsub;
+  });
+  const setToken = (next) => {
+    client.setAuthToken(next);
+  };
+  return { setToken, token, user };
+};
+
+export { auth };

package/dist/packem_shared/connectionStatus-CROr6jbn.mjs

@@ -0,0 +1,14 @@
+import { readable } from 'svelte/store';
+import { getLunoraClient } from './setLunoraClient--bwSz7F6.mjs';
+
+const connectionStatus = (client) => {
+  const resolved = client ?? getLunoraClient();
+  return readable(resolved.connectionStatus(), (set) => {
+    set(resolved.connectionStatus());
+    return resolved.onConnectionStatus((next) => {
+      set(next);
+    });
+  });
+};
+
+export { connectionStatus };

package/dist/packem_shared/hydratePreloaded-BUv3k4-s.mjs

@@ -0,0 +1,21 @@
+import { readable } from 'svelte/store';
+import { getLunoraClient } from './setLunoraClient--bwSz7F6.mjs';
+
+const hydratePreloaded = (preloaded, client) => {
+  const resolvedClient = client ?? getLunoraClient();
+  const { args, functionPath, shardKey, value } = preloaded;
+  const functionRef = { __lunoraRef: functionPath };
+  return readable(
+    value,
+    (set) => resolvedClient.subscribe(
+      functionRef,
+      args,
+      (next) => {
+        set(next);
+      },
+      { shardKey }
+    )
+  );
+};
+
+export { hydratePreloaded };

package/dist/packem_shared/is-function-reference-ycLAcI79.mjs

@@ -0,0 +1,3 @@
+const isFunctionReference = (value) => typeof value === "object" && value !== null && typeof value.__lunoraRef === "string";
+
+export { isFunctionReference as i };

package/dist/packem_shared/mutation-CA3qEPCB.mjs

@@ -0,0 +1,31 @@
+import { createMutationRunner } from '@lunora/client';
+import { writable } from 'svelte/store';
+import { getLunoraClient } from './setLunoraClient--bwSz7F6.mjs';
+
+function mutation(clientOrFunction, maybeFunction) {
+  const hasExplicitClient = maybeFunction !== void 0;
+  const client = hasExplicitClient ? clientOrFunction : getLunoraClient();
+  const functionRef = hasExplicitClient ? maybeFunction : clientOrFunction;
+  const data = writable();
+  const error = writable();
+  const pending = writable(false);
+  const mutate = createMutationRunner(client, functionRef, {
+    setError: (next) => {
+      error.set(next);
+    },
+    setPending: (next) => {
+      pending.set(next);
+    },
+    setResult: (result) => {
+      data.set(result);
+      error.set(void 0);
+    }
+  });
+  const reset = () => {
+    data.set(void 0);
+    error.set(void 0);
+  };
+  return { data, error, mutate, pending, reset };
+}
+
+export { mutation };

package/dist/packem_shared/paginatedQuery-CfCSITZv.mjs

@@ -0,0 +1,196 @@
+import { initialPages, derivePaginationStatus, rebalance, applyLoadMore } from '@lunora/client/pagination';
+import { derived, writable, readable } from 'svelte/store';
+import { getLunoraClient } from './setLunoraClient--bwSz7F6.mjs';
+import { i as isFunctionReference } from './is-function-reference-ycLAcI79.mjs';
+
+const buildPageArgs = (page, baseArgs) => {
+  return {
+    ...baseArgs,
+    paginationOpts: { cursor: page.lower, endCursor: page.upper, numItems: page.numItems }
+  };
+};
+const buildPageKey = (functionPath, pageArgs) => `${functionPath}::${JSON.stringify(pageArgs)}`;
+const createPaginatedEngine = (client, function_, baseArgs, options) => {
+  const { initialNumItems, shardKey } = options;
+  const pagesStore = writable(initialPages(initialNumItems));
+  const pageResultsInternal = writable([]);
+  const resultsByKey = /* @__PURE__ */ new Map();
+  const activeSubs = /* @__PURE__ */ new Map();
+  const pendingPageKeys = /* @__PURE__ */ new Set();
+  let currentPages = initialPages(initialNumItems);
+  const currentBaseArgs = baseArgs;
+  pagesStore.subscribe((pages) => {
+    currentPages = pages;
+  });
+  const rebuildPageResults = () => {
+    if (currentBaseArgs === "skip") {
+      pageResultsInternal.set([]);
+      return;
+    }
+    const updated = currentPages.map((page) => {
+      const key = buildPageKey(function_["__lunoraRef"], buildPageArgs(page, currentBaseArgs));
+      return resultsByKey.get(key);
+    });
+    pageResultsInternal.set(updated);
+  };
+  const syncSubscriptions = () => {
+    if (currentBaseArgs === "skip") {
+      for (const unsub of activeSubs.values()) {
+        unsub();
+      }
+      activeSubs.clear();
+      pageResultsInternal.set([]);
+      return;
+    }
+    const baseArgsRecord = currentBaseArgs;
+    const wantedKeys = /* @__PURE__ */ new Set();
+    for (const page of currentPages) {
+      wantedKeys.add(buildPageKey(function_["__lunoraRef"], buildPageArgs(page, baseArgsRecord)));
+    }
+    for (const [key, unsub] of activeSubs) {
+      if (!wantedKeys.has(key)) {
+        unsub();
+        activeSubs.delete(key);
+        pendingPageKeys.delete(key);
+      }
+    }
+    for (const page of currentPages) {
+      const pageArgs = buildPageArgs(page, baseArgsRecord);
+      const key = buildPageKey(function_["__lunoraRef"], pageArgs);
+      if (activeSubs.has(key)) {
+        continue;
+      }
+      pendingPageKeys.add(key);
+      const unsub = client.subscribe(
+        function_,
+        pageArgs,
+        (value) => {
+          resultsByKey.set(key, value);
+          pendingPageKeys.delete(key);
+          rebuildPageResults();
+          if (pendingPageKeys.size === 0) {
+            let updatedResults = [];
+            pageResultsInternal.subscribe((results) => {
+              updatedResults = results;
+            })();
+            const next = rebalance(currentPages, updatedResults);
+            if (next) {
+              pagesStore.set(next);
+              syncSubscriptions();
+              rebuildPageResults();
+            }
+          }
+        },
+        { shardKey }
+      );
+      activeSubs.set(key, unsub);
+    }
+  };
+  const teardownAll = () => {
+    for (const unsub of activeSubs.values()) {
+      unsub();
+    }
+    activeSubs.clear();
+    resultsByKey.clear();
+    pendingPageKeys.clear();
+  };
+  const pageResults = readable([], (set) => {
+    const unsubInternal = pageResultsInternal.subscribe(set);
+    if (currentBaseArgs !== "skip") {
+      syncSubscriptions();
+      rebuildPageResults();
+    }
+    return () => {
+      unsubInternal();
+      teardownAll();
+      pagesStore.set(initialPages(initialNumItems));
+      pageResultsInternal.set([]);
+    };
+  });
+  const status = derived(
+    pageResults,
+    (results) => derivePaginationStatus(currentBaseArgs === "skip", results).status
+  );
+  const loadMore = (numberItems) => {
+    if (currentBaseArgs === "skip") {
+      return;
+    }
+    let currentResults = [];
+    pageResultsInternal.subscribe((results) => {
+      currentResults = results;
+    })();
+    const { nextCursor, status: currentStatus } = derivePaginationStatus(false, currentResults);
+    if (currentStatus !== "CanLoadMore") {
+      return;
+    }
+    const next = applyLoadMore(currentPages, nextCursor, numberItems);
+    if (!next) {
+      return;
+    }
+    const oldTail = currentPages.at(-1);
+    const newPinnedPage = next.at(-2);
+    if (oldTail && newPinnedPage) {
+      const oldKey = buildPageKey(function_["__lunoraRef"], buildPageArgs(oldTail, currentBaseArgs));
+      const newKey = buildPageKey(function_["__lunoraRef"], buildPageArgs(newPinnedPage, currentBaseArgs));
+      if (oldKey !== newKey) {
+        const carried = resultsByKey.get(oldKey);
+        if (carried) {
+          resultsByKey.set(newKey, carried);
+        }
+      }
+    }
+    pagesStore.set(next);
+    syncSubscriptions();
+    rebuildPageResults();
+  };
+  return { loadMore, pageResults, status };
+};
+function paginatedQuery(clientOrFunction, functionOrArguments, argumentsOrOptions, maybeOptions) {
+  const hasExplicitClient = !isFunctionReference(clientOrFunction);
+  const client = hasExplicitClient ? clientOrFunction : getLunoraClient();
+  const functionRef = hasExplicitClient ? functionOrArguments : clientOrFunction;
+  const args = hasExplicitClient ? argumentsOrOptions : functionOrArguments;
+  const options = hasExplicitClient ? maybeOptions : argumentsOrOptions;
+  const { loadMore, pageResults, status } = createPaginatedEngine(client, functionRef, args, options);
+  const results = derived(pageResults, (currentResults) => {
+    const items = [];
+    for (const page of currentResults) {
+      if (page) {
+        items.push(...page.page);
+      }
+    }
+    return items;
+  });
+  const isLoading = derived(
+    status,
+    (currentStatus) => currentStatus === "LoadingFirstPage" || currentStatus === "LoadingMore"
+  );
+  return { isLoading, loadMore, results, status };
+}
+function infiniteQuery(clientOrFunction, functionOrArguments, argumentsOrOptions, maybeOptions) {
+  const hasExplicitClient = !isFunctionReference(clientOrFunction);
+  const client = hasExplicitClient ? clientOrFunction : getLunoraClient();
+  const functionRef = hasExplicitClient ? functionOrArguments : clientOrFunction;
+  const args = hasExplicitClient ? argumentsOrOptions : functionOrArguments;
+  const options = hasExplicitClient ? maybeOptions : argumentsOrOptions;
+  const { initialNumItems } = options;
+  const { loadMore, pageResults, status } = createPaginatedEngine(client, functionRef, args, options);
+  const pages = derived(pageResults, (currentResults) => {
+    const result = [];
+    for (const page of currentResults) {
+      if (page) {
+        result.push(page.page);
+      }
+    }
+    return result;
+  });
+  const isLoading = derived(status, (s) => s === "LoadingFirstPage");
+  const hasNextPage = derived(status, (s) => s === "CanLoadMore");
+  const isFetchingNextPage = derived(status, (s) => s === "LoadingMore");
+  const fetchNextPage = (numberItems) => {
+    loadMore(numberItems ?? initialNumItems);
+  };
+  return { fetchNextPage, hasNextPage, isFetchingNextPage, isLoading, pages, status };
+}
+
+export { infiniteQuery, paginatedQuery };

package/dist/packem_shared/presence-Bf-y7QzR.mjs

@@ -0,0 +1,66 @@
+import { readable } from 'svelte/store';
+import { getLunoraClient } from './setLunoraClient--bwSz7F6.mjs';
+
+const makeSessionId = () => {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return `sess-${Math.random().toString(36).slice(2)}-${String(Date.now())}`;
+};
+const DEFAULT_INTERVAL_MS = 1e4;
+const createPresenceHandle = (client, roomId, options) => {
+  const { heartbeat, intervalMs = DEFAULT_INTERVAL_MS, listPresent, shardKey } = options;
+  const sessionId = options.sessionId ?? makeSessionId();
+  let latestData = options.data;
+  const sendHeartbeat = () => {
+    const args = {
+      roomId,
+      sessionId,
+      ...latestData === void 0 ? {} : { data: latestData }
+    };
+    client.mutation(heartbeat, args, { shardKey }).catch(() => void 0);
+  };
+  const setData = (next) => {
+    latestData = next;
+    sendHeartbeat();
+  };
+  sendHeartbeat();
+  const intervalHandle = setInterval(sendHeartbeat, intervalMs);
+  const onVisible = () => {
+    if (typeof document !== "undefined" && document.visibilityState === "visible") {
+      sendHeartbeat();
+    }
+  };
+  if (typeof document !== "undefined") {
+    document.addEventListener("visibilitychange", onVisible);
+  }
+  const releaseConnectionContext = client.acquireConnectionContext({ roomId, sessionId }, { shardKey });
+  const present = readable(void 0, (set) => {
+    const unsubscribe = client.subscribe(
+      listPresent,
+      { roomId },
+      (value) => {
+        set(value);
+      },
+      { shardKey }
+    );
+    return unsubscribe;
+  });
+  const teardown = () => {
+    clearInterval(intervalHandle);
+    if (typeof document !== "undefined") {
+      document.removeEventListener("visibilitychange", onVisible);
+    }
+    releaseConnectionContext();
+  };
+  return { present, sessionId, setData, teardown };
+};
+function presence(clientOrRoomId, roomIdOrOptions, maybeOptions) {
+  const hasExplicitClient = typeof clientOrRoomId !== "string";
+  const client = hasExplicitClient ? clientOrRoomId : getLunoraClient();
+  const roomId = hasExplicitClient ? roomIdOrOptions : clientOrRoomId;
+  const options = hasExplicitClient ? maybeOptions : roomIdOrOptions;
+  return createPresenceHandle(client, roomId, options);
+}
+
+export { presence };

package/dist/packem_shared/query-B14VE2Qg.mjs

@@ -0,0 +1,36 @@
+import { createQuerySubscription } from '@lunora/client/query';
+import { readable } from 'svelte/store';
+import { getLunoraClient } from './setLunoraClient--bwSz7F6.mjs';
+import { i as isFunctionReference } from './is-function-reference-ycLAcI79.mjs';
+
+function query(clientOrFunction, functionOrArguments, argumentsOrOptions, maybeOptions) {
+  const hasExplicitClient = !isFunctionReference(clientOrFunction);
+  const client = hasExplicitClient ? clientOrFunction : getLunoraClient();
+  const functionRef = hasExplicitClient ? functionOrArguments : clientOrFunction;
+  const args = hasExplicitClient ? argumentsOrOptions : functionOrArguments;
+  const options = (hasExplicitClient ? maybeOptions : argumentsOrOptions) ?? {};
+  return readable(
+    void 0,
+    (set) => (
+      // The shared `@lunora/client/query` state machine owns the subscribe +
+      // cleanup: it replays the last value synchronously when one exists and
+      // pushes every subsequent delta into the store, and its returned teardown
+      // is the store's stop callback, so the WS subscription closes when the
+      // last `$`-reader detaches.
+      createQuerySubscription(
+        client,
+        functionRef,
+        args,
+        {
+          onData: (value) => {
+            set(value);
+          },
+          onError: options.onError
+        },
+        { shardKey: options.shardKey }
+      )
+    )
+  );
+}
+
+export { query };

package/dist/packem_shared/rateLimit-Cdw1kp8t.mjs

@@ -0,0 +1,66 @@
+import { evaluate } from '@lunora/ratelimit';
+import { writable, derived } from 'svelte/store';
+
+const rateLimit = (config, options = {}) => {
+  const now = options.now ?? Date.now;
+  const tickMs = options.tickMs ?? 1e3;
+  let value;
+  const epoch = writable(0);
+  const bump = () => {
+    epoch.update((n) => n + 1);
+  };
+  const status = derived(epoch, () => evaluate(config, value, { consume: false, count: 1, now: now(), reserve: false }).status);
+  let intervalHandle;
+  const stopInterval = () => {
+    if (intervalHandle !== void 0) {
+      clearInterval(intervalHandle);
+      intervalHandle = void 0;
+    }
+  };
+  let latestOk = true;
+  const unsubStatus = status.subscribe((s) => {
+    latestOk = s.ok;
+  });
+  const startIntervalIfThrottled = () => {
+    if (latestOk || intervalHandle !== void 0) {
+      return;
+    }
+    intervalHandle = setInterval(() => {
+      bump();
+      if (latestOk) {
+        stopInterval();
+      }
+    }, tickMs);
+  };
+  startIntervalIfThrottled();
+  const consume = (count = 1) => {
+    const result = evaluate(config, value, { consume: true, count, now: now(), reserve: false });
+    if (result.value !== void 0) {
+      value = result.value;
+    }
+    bump();
+    startIntervalIfThrottled();
+    return result.status;
+  };
+  const check = (count = 1) => evaluate(config, value, { consume: false, count, now: now(), reserve: false }).status.ok;
+  const reset = () => {
+    value = void 0;
+    stopInterval();
+    bump();
+  };
+  const teardown = () => {
+    stopInterval();
+    unsubStatus();
+  };
+  return {
+    check,
+    consume,
+    disabled: derived(status, (s) => !s.ok),
+    ok: derived(status, (s) => s.ok),
+    reset,
+    retryAfter: derived(status, (s) => s.retryAfter),
+    teardown
+  };
+};
+
+export { rateLimit };

package/dist/packem_shared/setLunoraClient--bwSz7F6.mjs

@@ -0,0 +1,16 @@
+import { setContext, getContext } from 'svelte';
+
+const LUNORA_CONTEXT_KEY = /* @__PURE__ */ Symbol("lunora.client");
+const setLunoraClient = (client) => {
+  setContext(LUNORA_CONTEXT_KEY, client);
+  return client;
+};
+const getLunoraClient = () => {
+  const client = getContext(LUNORA_CONTEXT_KEY);
+  if (!client) {
+    throw new Error("getLunoraClient(): no LunoraClient in context — call setLunoraClient(client) in an ancestor component first.");
+  }
+  return client;
+};
+
+export { getLunoraClient, setLunoraClient };

package/dist/packem_shared/subscription-B3HDNcpq.mjs

@@ -0,0 +1,46 @@
+import { createQuerySubscription } from '@lunora/client/query';
+import { writable, readable } from 'svelte/store';
+import { getLunoraClient } from './setLunoraClient--bwSz7F6.mjs';
+import { i as isFunctionReference } from './is-function-reference-ycLAcI79.mjs';
+
+function subscription(clientOrFunction, functionOrArgs, argsOrOptions, maybeOptions) {
+  const hasExplicitClient = !isFunctionReference(clientOrFunction);
+  const client = hasExplicitClient ? clientOrFunction : getLunoraClient();
+  const functionRef = hasExplicitClient ? functionOrArgs : clientOrFunction;
+  const args = hasExplicitClient ? argsOrOptions : functionOrArgs;
+  const options = (hasExplicitClient ? maybeOptions : argsOrOptions) ?? {};
+  const { shardKey, onError } = options;
+  const errorStore = writable();
+  const data = readable(void 0, (set) => {
+    if (args === "skip") {
+      return () => void 0;
+    }
+    const unsubscribe = createQuerySubscription(
+      client,
+      functionRef,
+      args,
+      {
+        onData: (value) => {
+          set(value);
+          errorStore.set(void 0);
+        },
+        onError: (subscriptionError) => {
+          const error = new Error(subscriptionError.message);
+          errorStore.set(error);
+          onError?.(error);
+        },
+        onReset: () => {
+          set(void 0);
+        }
+      },
+      { shardKey }
+    );
+    return () => {
+      unsubscribe();
+      errorStore.set(void 0);
+    };
+  });
+  return { data, error: { subscribe: errorStore.subscribe } };
+}
+
+export { subscription };

package/dist/server.d.mts

@@ -0,0 +1 @@
+export { type ArgsOf, type AuthLike, type FunctionReference, type HeadersSource, type Preloaded, type ReturnOf, type ServerClientOptions, type ServerSession, createServerClient, deserializePreloaded, getServerSession, preloadQuery, preloadedQueryResult, serializePreloaded } from '@lunora/client/ssr';

package/dist/server.d.ts

@@ -0,0 +1 @@
+export { type ArgsOf, type AuthLike, type FunctionReference, type HeadersSource, type Preloaded, type ReturnOf, type ServerClientOptions, type ServerSession, createServerClient, deserializePreloaded, getServerSession, preloadQuery, preloadedQueryResult, serializePreloaded } from '@lunora/client/ssr';

package/dist/server.mjs

@@ -0,0 +1 @@
+export { createServerClient, deserializePreloaded, getServerSession, preloadQuery, preloadedQueryResult, serializePreloaded } from '@lunora/client/ssr';

package/dist/worker.d.mts

@@ -0,0 +1 @@
+export { type ExecutionContextLike, type FrameworkWorkerOptions as LunoraWorkerOptions, type FrameworkWorkerOptionsInput as LunoraWorkerOptionsInput, type FrameworkHostHandler as SvelteKitWorker, withFrameworkWorker as withLunora } from '@lunora/runtime';

package/dist/worker.d.ts

@@ -0,0 +1 @@
+export { type ExecutionContextLike, type FrameworkWorkerOptions as LunoraWorkerOptions, type FrameworkWorkerOptionsInput as LunoraWorkerOptionsInput, type FrameworkHostHandler as SvelteKitWorker, withFrameworkWorker as withLunora } from '@lunora/runtime';

package/dist/worker.mjs

@@ -0,0 +1 @@
+export { withFrameworkWorker as withLunora } from '@lunora/runtime';

package/package.json

@@ -1,31 +1,72 @@
 {
   "name": "@lunora/svelte",
-  "version": "0.0.0",
+  "version": "1.0.0-alpha.1",
   "description": "Svelte adapter for Lunora — live stores, optimistic mutations, and reactive loaders",
-  "license": "FSL-1.1-Apache-2.0",
+  "keywords": [
+    "cloudflare",
+    "durable-objects",
+    "lunora",
+    "optimistic-updates",
+    "realtime",
+    "stores",
+    "svelte",
+    "workers"
+  ],
   "homepage": "https://lunora.sh",
+  "bugs": "https://github.com/anolilab/lunora/issues",
+  "license": "FSL-1.1-Apache-2.0",
+  "author": {
+    "name": "Daniel Bannert",
+    "email": "d.bannert@anolilab.de"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/anolilab/lunora.git",
     "directory": "packages/svelte"
   },
-  "bugs": {
-    "url": "https://github.com/anolilab/lunora/issues"
-  },
-  "keywords": [
-    "lunora",
-    "cloudflare",
-    "workers",
-    "durable-objects",
-    "svelte",
-    "stores",
-    "realtime",
-    "optimistic-updates"
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE.md",
+    "__assets__"
   ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.mjs"
+    },
+    "./worker": {
+      "types": "./dist/worker.d.ts",
+      "import": "./dist/worker.mjs"
+    },
+    "./package.json": "./package.json"
+  },
   "publishConfig": {
     "access": "public"
   },
-  "files": [
-    "README.md"
-  ]
+  "dependencies": {
+    "@lunora/client": "1.0.0-alpha.1",
+    "@lunora/ratelimit": "1.0.0-alpha.1",
+    "@lunora/runtime": "1.0.0-alpha.1"
+  },
+  "peerDependencies": {
+    "svelte": "^5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "svelte": {
+      "optional": false
+    }
+  },
+  "engines": {
+    "node": "^22.15.0 || >=24.11.0"
+  }
 }