akanjs 0.0.1 → 2.0.0-beta.0

package/fetch/fetchType/sliceFetch.type.ts

@@ -0,0 +1,173 @@
+import type { GetStateObject, SLICE_META } from "akanjs/base";
+import type { FetchPolicy } from "akanjs/common";
+import type { ConstantModel, DefaultOf, ProtoFile, PurifiedModel } from "akanjs/constant";
+import type { DatabaseModel, ExtractSort, FilterInstance } from "akanjs/document";
+import type { SliceCls, SliceInfoArgs } from "akanjs/signal";
+import type { ClientEdit, ClientInit, ClientView, EditReturn, InitReturn, ViewReturn } from "./appliedReturn.type";
+
+type _SliceMap<S extends SliceCls> = S[typeof SLICE_META];
+type _RefName<S extends SliceCls> = S["srv"]["cnst"]["refName"];
+type _Cap<S extends SliceCls> = S["srv"]["cnst"]["_CapitalizedRefName"];
+type _Input<S extends SliceCls> = S["srv"]["cnst"]["_Input"];
+type _Full<S extends SliceCls> = S["srv"]["cnst"]["_Full"];
+type _Light<S extends SliceCls> = S["srv"]["cnst"]["_Light"];
+type _Insight<S extends SliceCls> = S["srv"]["cnst"]["_Insight"];
+type _PurifiedInput<S extends SliceCls> = S["srv"]["cnst"]["_PurifiedInput"];
+type _DefaultInput<S extends SliceCls> = S["srv"]["cnst"]["_DefaultInput"];
+type _StateLight<S extends SliceCls> = S["srv"]["cnst"]["_StateLight"];
+type _StateInsight<S extends SliceCls> = S["srv"]["cnst"]["_StateInsight"];
+type _Filter<S extends SliceCls> = S["srv"]["db"]["_Filter"];
+type _Sort<S extends SliceCls> = S["srv"]["db"]["_Sort"];
+type _LightWithId<S extends SliceCls> = _Light<S> extends { id: string } ? _Light<S> : { id: string };
+type _SliceFetchInitOption<S extends SliceCls> = FetchInitOption<_Input<S>, _Filter<S>, _DefaultInput<S>, _Sort<S>>;
+
+type SliceListFetch<S extends SliceCls> = {
+  [Suffix in keyof _SliceMap<S> as Suffix extends string ? `${_RefName<S>}List${Capitalize<Suffix>}` : never]: (
+    ...args: [
+      ...SliceInfoArgs<_SliceMap<S>[Suffix]>,
+      skip?: number | null,
+      limit?: number | null,
+      sort?: _Sort<S> | null,
+      fetchPolicy?: FetchPolicy,
+    ]
+  ) => Promise<_Light<S>[]>;
+};
+
+type SliceInsightFetch<S extends SliceCls> = {
+  [Suffix in keyof _SliceMap<S> as Suffix extends string ? `${_RefName<S>}Insight${Capitalize<Suffix>}` : never]: (
+    ...args: [...SliceInfoArgs<_SliceMap<S>[Suffix]>, fetchPolicy?: FetchPolicy]
+  ) => Promise<_Insight<S>>;
+};
+
+type SliceInitFetch<S extends SliceCls> = {
+  [Suffix in keyof _SliceMap<S> as Suffix extends string ? `init${_Cap<S>}${Capitalize<Suffix>}` : never]: (
+    ...args: [...SliceInfoArgs<_SliceMap<S>[Suffix]>, option?: _SliceFetchInitOption<S>]
+  ) => Promise<
+    InitReturn<
+      _RefName<S>,
+      Suffix & string,
+      _Light<S>,
+      _Insight<S>,
+      SliceInfoArgs<_SliceMap<S>[Suffix]>,
+      _Filter<S>,
+      _Cap<S>,
+      Suffix extends string ? Capitalize<Suffix> : never,
+      _LightWithId<S>,
+      GetStateObject<_LightWithId<S>>,
+      GetStateObject<_Insight<S>>,
+      _Sort<S>
+    >
+  >;
+};
+
+type SliceGetInitFetch<S extends SliceCls> = {
+  [Suffix in keyof _SliceMap<S> as Suffix extends string ? `get${_Cap<S>}Init${Capitalize<Suffix>}` : never]: (
+    ...args: [...SliceInfoArgs<_SliceMap<S>[Suffix]>, option?: _SliceFetchInitOption<S>]
+  ) => ClientInit<
+    _RefName<S>,
+    _Light<S>,
+    _Insight<S>,
+    SliceInfoArgs<_SliceMap<S>[Suffix]>,
+    _Filter<S>,
+    _Cap<S>,
+    GetStateObject<_LightWithId<S>>,
+    GetStateObject<_Insight<S>>,
+    _Sort<S>
+  >;
+};
+
+export type GetFetchTypeFromSlice<SlceCls extends SliceCls> = SlceCls["srv"]["cnst"] extends ConstantModel
+  ? SlceCls["srv"]["db"] extends DatabaseModel
+    ? SliceListFetch<SlceCls> &
+        SliceInsightFetch<SlceCls> &
+        SliceInitFetch<SlceCls> &
+        SliceGetInitFetch<SlceCls> &
+        RawBaseSliceFetchType<
+          _RefName<SlceCls>,
+          _Input<SlceCls>,
+          _Full<SlceCls>,
+          _Light<SlceCls>,
+          _Cap<SlceCls>,
+          _PurifiedInput<SlceCls>
+        > &
+        AppliedBaseSliceFetchType<
+          _RefName<SlceCls>,
+          _Input<SlceCls>,
+          _Full<SlceCls>,
+          _Cap<SlceCls>,
+          _PurifiedInput<SlceCls>
+        >
+    : never
+  : never;
+
+type RawBaseSliceFetchType<
+  RefName extends string,
+  Input,
+  Full,
+  Light,
+  _CapitalizedRefName extends string = Capitalize<RefName>,
+  _PurifiedInput = PurifiedModel<Input>,
+> = {
+  [K in RefName]: (id: string, fetchPolicy?: FetchPolicy) => Promise<Full>;
+} & {
+  [K in `light${_CapitalizedRefName}`]: (id: string, fetchPolicy?: FetchPolicy) => Promise<Light>;
+} & {
+  [K in `create${_CapitalizedRefName}`]: (input: _PurifiedInput, fetchPolicy?: FetchPolicy) => Promise<Full>;
+} & {
+  [K in `update${_CapitalizedRefName}`]: (
+    id: string,
+    input: _PurifiedInput,
+    fetchPolicy?: FetchPolicy,
+  ) => Promise<Full>;
+} & {
+  [K in `remove${_CapitalizedRefName}`]: (id: string, fetchPolicy?: FetchPolicy) => Promise<void>;
+};
+
+type AppliedBaseSliceFetchType<
+  RefName extends string,
+  Input,
+  Full,
+  _CapitalizedRefName extends string = Capitalize<RefName>,
+  _PurifiedInput = PurifiedModel<Input>,
+> = {
+  [K in `view${_CapitalizedRefName}`]: (id: string, option?: FetchPolicy) => Promise<ViewReturn<RefName, Full>>;
+} & {
+  [K in `get${_CapitalizedRefName}View`]: (id: string, option?: FetchPolicy) => ClientView<RefName, Full>;
+} & {
+  [K in `edit${_CapitalizedRefName}`]: (id: string, option?: FetchPolicy) => Promise<EditReturn<RefName, Full>>;
+} & {
+  [K in `get${_CapitalizedRefName}Edit`]: (id: string, option?: FetchPolicy) => ClientEdit<RefName, Full>;
+} & {
+  [K in `add${_CapitalizedRefName}Files`]: (
+    fileList: FileList,
+    parentId?: string,
+    option?: FetchPolicy,
+  ) => Promise<ProtoFile[]>;
+} & {
+  [K in `merge${_CapitalizedRefName}`]: (
+    modelOrId: Full | string,
+    data: Partial<_PurifiedInput>,
+    option?: FetchPolicy,
+  ) => Promise<Full>;
+};
+
+export interface FetchInitForm<
+  Input,
+  Filter extends FilterInstance,
+  _DefaultInput = DefaultOf<Input>,
+  _Sort = ExtractSort<Filter>,
+> {
+  page?: number;
+  limit?: number;
+  sort?: _Sort;
+  default?: Partial<_DefaultInput>;
+  invalidate?: boolean;
+  insight?: boolean;
+}
+
+type FetchInitOption<
+  Input,
+  Filter extends FilterInstance,
+  _DefaultInput = DefaultOf<Input>,
+  _Sort = ExtractSort<Filter>,
+> = FetchPolicy & FetchInitForm<Input, Filter, _DefaultInput, _Sort>;

package/fetch/index.ts

@@ -0,0 +1,4 @@
+export * from "./client";
+export * from "./fetchType";
+export * from "./requestStorage";
+export * from "./types";

package/fetch/requestStorage.ts

@@ -0,0 +1,127 @@
+export interface RequestStorage {
+  run<T>(store: Request, callback: () => T): T;
+  getStore(): Request | undefined;
+}
+
+export type AkanTheme = "css" | "system" | (string & {});
+
+declare global {
+  var __AKAN_REQUEST_STORAGE__: RequestStorage | undefined;
+  var __AKAN_REQUEST_THEME__: WeakMap<Request, AkanTheme> | undefined;
+  var __AKAN_REQUEST_QUERY_CACHE__: WeakMap<Request, Map<string, Promise<unknown>>> | undefined;
+  var __AKAN_REQUEST_FALLBACK_STACK__: Request[] | undefined;
+}
+
+let _requestStorage: RequestStorage | null = null;
+if (typeof window === "undefined") {
+  try {
+
+    const { AsyncLocalStorage } = require("node:async_hooks") as typeof import("node:async_hooks");
+    globalThis.__AKAN_REQUEST_STORAGE__ ??= new AsyncLocalStorage() as RequestStorage;
+    _requestStorage = globalThis.__AKAN_REQUEST_STORAGE__;
+  } catch {}
+}
+
+export const requestStorage: RequestStorage | null = _requestStorage;
+
+function requestThemeMap(): WeakMap<Request, AkanTheme> {
+  globalThis.__AKAN_REQUEST_THEME__ ??= new WeakMap<Request, AkanTheme>();
+  return globalThis.__AKAN_REQUEST_THEME__;
+}
+
+function requestQueryCacheMap(): WeakMap<Request, Map<string, Promise<unknown>>> {
+  globalThis.__AKAN_REQUEST_QUERY_CACHE__ ??= new WeakMap<Request, Map<string, Promise<unknown>>>();
+  return globalThis.__AKAN_REQUEST_QUERY_CACHE__;
+}
+
+/** Stores theme preference on the active request when server rendering. */
+export function setRequestTheme(theme: AkanTheme | undefined): void {
+  const req = getRequest();
+  if (!req || theme === undefined) return;
+  requestThemeMap().set(req, theme);
+}
+
+export function getRequestTheme(): AkanTheme | undefined {
+  const req = getRequest();
+  if (!req) return undefined;
+  return requestThemeMap().get(req);
+}
+
+export function pushRequestFallback(req: Request): () => void {
+  globalThis.__AKAN_REQUEST_FALLBACK_STACK__ ??= [];
+  const stack = globalThis.__AKAN_REQUEST_FALLBACK_STACK__;
+  stack.push(req);
+  return () => {
+    const index = stack.lastIndexOf(req);
+    if (index >= 0) stack.splice(index, 1);
+  };
+}
+
+/** Returns the active server request from AsyncLocalStorage or the fallback stack. */
+export function getRequest(): Request | undefined {
+  return requestStorage?.getStore() ?? globalThis.__AKAN_REQUEST_FALLBACK_STACK__?.at(-1);
+}
+
+/** Deduplicates a promise-producing query within the active request. */
+export function memoizeRequestQuery<T>(key: string, factory: () => Promise<T>): Promise<T> {
+  const req = getRequest();
+  if (!req) return factory();
+  const cacheMap = requestQueryCacheMap();
+  let cache = cacheMap.get(req);
+  if (!cache) {
+    cache = new Map<string, Promise<unknown>>();
+    cacheMap.set(req, cache);
+  }
+  const existing = cache.get(key);
+  if (existing) return existing as Promise<T>;
+  const promise = factory();
+  cache.set(key, promise);
+  return promise;
+}
+
+/** Returns current request headers as a Map, or an empty Map outside a request. */
+export function headers(): Map<string, string> {
+  const req = getRequest();
+  const map = new Map<string, string>();
+  if (!req) return map;
+  req.headers.forEach((value, key) => {
+    map.set(key, value);
+  });
+  return map;
+}
+
+export interface CookieEntry {
+  name: string;
+  value: string;
+}
+
+export function parseCookieHeader(cookieHeader: string): Map<string, CookieEntry> {
+  const out = new Map<string, CookieEntry>();
+  for (const segment of cookieHeader.split(";")) {
+    const trimmed = segment.trim();
+    if (!trimmed) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq === -1) continue;
+    const name = trimmed.slice(0, eq).trim();
+    const raw = trimmed.slice(eq + 1).trim();
+    
+    const value = raw.startsWith("j:")
+      ? (() => {
+          try {
+            return JSON.parse(raw.slice(2)) as string;
+          } catch {
+            return raw;
+          }
+        })()
+      : raw;
+    out.set(name, { name, value });
+  }
+  return out;
+}
+
+/** Returns parsed cookies from the current request, or an empty Map outside a request. */
+export function cookies(): Map<string, CookieEntry> {
+  const req = getRequest();
+  if (!req) return new Map();
+  return parseCookieHeader(req.headers.get("cookie") ?? "");
+}

package/fetch/serializer/fetch.serializer.ts

@@ -0,0 +1,131 @@
+import { type Cls, ENDPOINT_META, PrimitiveRegistry, type PrimitiveScalar, SLICE_META } from "akanjs/base";
+import { Logger } from "akanjs/common";
+import { ConstantRegistry, type ConstantType } from "akanjs/constant";
+import type { LiveRegistry } from "akanjs/service";
+import type {
+  ArgInfo,
+  EndpointArgProps,
+  EndpointCls,
+  EndpointInfo,
+  SerializedArg,
+  SerializedEndpoint,
+  SerializedReturns,
+  SerializedSignal,
+  SerializedSlice,
+  SliceCls,
+  SliceInfo,
+} from "akanjs/signal";
+
+export class FetchSerializer {
+  static logger = new Logger("FetchSerializer");
+
+  static #resolveRefInfo(modelRef: Cls): { refName: string; modelType?: ConstantType } {
+    if (PrimitiveRegistry.has(modelRef))
+      return { refName: PrimitiveRegistry.getName(modelRef as typeof PrimitiveScalar) };
+    const refName = ConstantRegistry.getRefName(modelRef);
+    const modelType = (modelRef as Cls<unknown, { modelType?: ConstantType }>).modelType;
+    return { refName, modelType };
+  }
+
+  static #serializeArg(argInfo: ArgInfo<EndpointArgProps<boolean>>): SerializedArg {
+    const { refName, modelType } = FetchSerializer.#resolveRefInfo(argInfo.argRef as Cls);
+    return {
+      type: argInfo.type,
+      refName,
+      name: argInfo.name,
+      ...(modelType ? { modelType: modelType as SerializedArg["modelType"] } : {}),
+      ...(argInfo.arrDepth ? { arrDepth: argInfo.arrDepth } : {}),
+      ...(argInfo.option?.nullable ? { nullable: true } : {}),
+      ...(argInfo.option?.example != null
+        ? {
+            example:
+              typeof argInfo.option.example === "object" ? argInfo.option.example.toDate() : argInfo.option.example,
+          }
+        : {}),
+    };
+  }
+
+  static #serializeReturns(endpointInfo: EndpointInfo): SerializedReturns {
+    const { refName, modelType } = FetchSerializer.#resolveRefInfo(endpointInfo.returns.returnRef as Cls);
+    return {
+      refName,
+      ...(modelType ? { modelType: modelType as SerializedReturns["modelType"] } : {}),
+      ...(endpointInfo.returns.arrDepth ? { arrDepth: endpointInfo.returns.arrDepth } : {}),
+      ...(endpointInfo.signalOption.partial?.length ? { partial: endpointInfo.signalOption.partial as string[] } : {}),
+      ...(endpointInfo.signalOption.nullable ? { nullable: true } : {}),
+    };
+  }
+
+  static #serializeEndpoint(endpointInfo: EndpointInfo): SerializedEndpoint {
+    const guards = endpointInfo.signalOption.guards?.map((g) => g.name);
+    return {
+      type: endpointInfo.type,
+      args: endpointInfo.args.map(FetchSerializer.#serializeArg),
+      returns: FetchSerializer.#serializeReturns(endpointInfo),
+      ...(endpointInfo.signalOption.path ? { path: endpointInfo.signalOption.path } : {}),
+      ...(endpointInfo.signalOption.prefix !== undefined ? { prefix: endpointInfo.signalOption.prefix } : {}),
+      ...(endpointInfo.signalOption.globalPrefix !== undefined
+        ? { globalPrefix: endpointInfo.signalOption.globalPrefix }
+        : {}),
+      ...(guards?.length ? { guards } : {}),
+    };
+  }
+
+  static #serializeSlice(sliceInfo: SliceInfo): SerializedSlice {
+    const guards = sliceInfo.signalOption.guards?.map((g) => g.name);
+    return {
+      args: sliceInfo.args.map(FetchSerializer.#serializeArg),
+      ...(sliceInfo.signalOption.path ? { path: sliceInfo.signalOption.path } : {}),
+      ...(guards?.length ? { guards } : {}),
+    };
+  }
+
+  static serializeDatabaseSignal(sliceCls: SliceCls, endpointCls: EndpointCls): SerializedSignal {
+    const sliceMeta = sliceCls[SLICE_META] as { [key: string]: SliceInfo };
+    const endpointMeta = endpointCls[ENDPOINT_META] as { [key: string]: EndpointInfo };
+    const prefix = sliceCls.srv.cnst?.refName;
+    const slice: { [key: string]: SerializedSlice } = {};
+    for (const [key, sliceInfo] of Object.entries(sliceMeta)) {
+      slice[key] = FetchSerializer.#serializeSlice(sliceInfo);
+    }
+    const endpoint: { [key: string]: SerializedEndpoint } = {};
+    for (const [key, endpointInfo] of Object.entries(endpointMeta)) {
+      endpoint[key] = FetchSerializer.#serializeEndpoint(endpointInfo);
+    }
+    return {
+      ...(prefix ? { prefix } : {}),
+      ...(Object.keys(slice).length ? { slice } : {}),
+      ...(sliceCls.getGuards.filter((g) => g.name !== "None").length
+        ? { getGuards: sliceCls.getGuards.map((g) => g.name) }
+        : {}),
+      ...(sliceCls.cruGuards.filter((g) => g.name !== "None").length
+        ? { cruGuards: sliceCls.cruGuards.map((g) => g.name) }
+        : {}),
+      endpoint,
+    };
+  }
+
+  static serializeServiceSignal(endpointCls: EndpointCls): SerializedSignal {
+    const endpointMeta = endpointCls[ENDPOINT_META] as { [key: string]: EndpointInfo };
+    const endpoint: { [key: string]: SerializedEndpoint } = {};
+    for (const [key, endpointInfo] of Object.entries(endpointMeta)) {
+      endpoint[key] = FetchSerializer.#serializeEndpoint(endpointInfo);
+    }
+    return { endpoint };
+  }
+
+  static serializeRegistry({ endpointCls, sliceCls }: LiveRegistry): { signal: { [key: string]: SerializedSignal } } {
+    const serializedSignals: { [key: string]: SerializedSignal } = {};
+    for (const [baseName, endpoint] of endpointCls.entries()) {
+      const cnst = endpoint.srv.cnst;
+      if (cnst) {
+        const slice = sliceCls.get(baseName);
+        if (!slice) throw new Error(`No slice found for service signal "${baseName}"`);
+        serializedSignals[baseName] = FetchSerializer.serializeDatabaseSignal(slice, endpoint);
+      } else {
+        serializedSignals[baseName] = FetchSerializer.serializeServiceSignal(endpoint);
+      }
+    }
+    return { signal: serializedSignals };
+  }
+}

package/fetch/serializer/index.ts

@@ -0,0 +1 @@
+export * from "./fetch.serializer";

package/fetch/types.ts

@@ -0,0 +1,28 @@
+import { type Environment, getEnv, type SLICE_META } from "akanjs/base";
+import type { DatabaseSignal } from "akanjs/signal";
+import type { SliceMeta } from "./fetchType/appliedReturn.type";
+
+/** Account data made available to services for the current app/environment. */
+export type Account<AddData = unknown> = {
+  appName: string;
+  environment: Environment;
+} & AddData;
+export const getDefaultAccount = (): Account => {
+  const env = getEnv();
+  return { appName: env.appName, environment: env.environment };
+};
+
+type GetSliceNameFromSignal<Signal> =
+  Signal extends DatabaseSignal<any, any, any, any>
+    ? `${Signal["slice"]["baseName"]}${Capitalize<keyof Signal["slice"][typeof SLICE_META] & string>}`
+    : Signal extends { slice: { [K in infer Key]: SliceMeta } }
+      ? Key
+      : never;
+type GetSliceNamesFromSignals<Signals> = Signals extends [infer First, ...infer Rest]
+  ? Rest extends []
+    ? GetSliceNameFromSignal<First>
+    : GetSliceNamesFromSignals<Rest> | GetSliceNameFromSignal<First>
+  : never;
+export type GetSliceMetaObjFromDatabaseSignals<Signals extends unknown[]> = {
+  [K in GetSliceNamesFromSignals<Signals>]: SliceMeta;
+};

package/package.json

@@ -1,10 +1,207 @@
 {
   "name": "akanjs",
-  "version": "0.0.1",
-  "type": "commonjs",
+  "version": "2.0.0-beta.0",
+  "sourceType": "module",
+  "type": "module",
   "bin": {
-    "runtest": "src/run.js"
+    "akan": "./cli/index.js",
+    "akan2": "./cli/index.js"
   },
-  "types": "./src/index.d.ts",
-  "main": "./src/index.js"
+  "publishConfig": {
+    "access": "public"
+  },
+  "homepage": "https://akanjs.com",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/akan-team/akanjs.git",
+    "directory": "pkgs/akanjs"
+  },
+  "exports": {
+    ".": {
+      "import": "./index.ts",
+      "types": "./index.ts",
+      "default": "./index.ts"
+    },
+    "./package.json": "./package.json",
+    "./capacitor.base.config": {
+      "import": "./devkit/capacitor.base.config.ts",
+      "types": "./devkit/capacitor.base.config.ts",
+      "default": "./devkit/capacitor.base.config.ts"
+    },
+    "./base": {
+      "import": "./base/index.ts",
+      "types": "./base/index.ts",
+      "default": "./base/index.ts"
+    },
+    "./common": {
+      "import": "./common/index.ts",
+      "types": "./common/index.ts",
+      "default": "./common/index.ts"
+    },
+    "./common/*": "./common/*",
+    "./fetch": {
+      "import": "./fetch/index.ts",
+      "types": "./fetch/index.ts",
+      "default": "./fetch/index.ts"
+    },
+    "./document": {
+      "import": "./document/index.ts",
+      "types": "./document/index.ts",
+      "default": "./document/index.ts"
+    },
+    "./signal": {
+      "import": "./signal/index.ts",
+      "types": "./signal/index.ts",
+      "default": "./signal/index.ts"
+    },
+    "./store": {
+      "import": "./store/index.ts",
+      "types": "./store/index.ts",
+      "default": "./store/index.ts"
+    },
+    "./ui": {
+      "import": "./ui/index.ts",
+      "types": "./ui/index.ts",
+      "default": "./ui/index.ts"
+    },
+    "./ui/*": "./ui/*",
+    "./client": {
+      "import": "./client/index.ts",
+      "types": "./client/index.ts",
+      "default": "./client/index.ts"
+    },
+    "./webkit": {
+      "import": "./webkit/index.ts",
+      "types": "./webkit/index.ts",
+      "default": "./webkit/index.ts"
+    },
+    "./webkit/*": "./webkit/*",
+    "./server": {
+      "import": "./server/index.ts",
+      "types": "./server/index.ts",
+      "default": "./server/index.ts"
+    },
+    "./service": {
+      "import": "./service/index.ts",
+      "types": "./service/index.ts",
+      "default": "./service/index.ts"
+    },
+    "./constant": {
+      "import": "./constant/index.ts",
+      "types": "./constant/index.ts",
+      "default": "./constant/index.ts"
+    },
+    "./dictionary": {
+      "import": "./dictionary/index.ts",
+      "types": "./dictionary/index.ts",
+      "default": "./dictionary/index.ts"
+    },
+    "./devkit": {
+      "import": "./devkit/index.ts",
+      "types": "./devkit/index.ts",
+      "default": "./devkit/index.ts"
+    },
+    "./test": {
+      "import": "./test/index.ts",
+      "types": "./test/index.ts",
+      "default": "./test/index.ts"
+    },
+    "./cli": {
+      "import": "./cli/index.ts",
+      "types": "./cli/index.ts",
+      "default": "./cli/index.ts"
+    },
+    "./ui/styles.css": "./ui/styles.css",
+    "./server/rsc-worker": {
+      "import": "./server/rscWorker.tsx",
+      "types": "./server/rscWorker.tsx",
+      "default": "./server/rscWorker.tsx"
+    }
+  },
+  "dependencies": {
+    "@capacitor-community/contacts": "^7.2.0",
+    "@capacitor-community/fcm": "^8.1.0",
+    "@capacitor/app": "^8.1.0",
+    "@capacitor/browser": "^8.0.3",
+    "@capacitor/camera": "^8.2.0",
+    "@capacitor/core": "^8.3.4",
+    "@capacitor/device": "^8.0.2",
+    "@capacitor/geolocation": "^8.2.0",
+    "@capacitor/haptics": "^8.0.2",
+    "@capacitor/keyboard": "^8.0.3",
+    "@capacitor/preferences": "^8.0.1",
+    "@capacitor/push-notifications": "^8.1.1",
+    "@capgo/capacitor-updater": "^8.46.1",
+    "@formatjs/intl-localematcher": "^0.8.8",
+    "@inquirer/prompts": "^8.4.3",
+    "@langchain/core": "^1.1.47",
+    "@langchain/deepseek": "^1.0.26",
+    "@langchain/openai": "^1.4.6",
+    "@libsql/client": "^0.17.3",
+    "@playwright/test": "^1.60.0",
+    "@radix-ui/react-dialog": "^1.1.15",
+    "@react-spring/web": "^9.7.5",
+    "@trapezedev/project": "^7.1.4",
+    "@use-gesture/react": "^10.3.1",
+    "bullmq": "^5.76.10",
+    "capacitor-plugin-safe-area": "^5.0.0",
+    "chalk": "^5.6.2",
+    "chance": "^1.1.13",
+    "clsx": "^2.1.1",
+    "commander": "^14.0.3",
+    "compare-versions": "^6.1.1",
+    "cordova-plugin-purchase": "^13.16.0",
+    "croner": "^10.0.1",
+    "dataloader": "^2.2.3",
+    "dayjs": "^1.11.20",
+    "file-saver": "^2.0.5",
+    "fontaine": "^0.8.0",
+    "fonteditor-core": "^2.6.3",
+    "ignore": "^7.0.5",
+    "immer": "^11.1.8",
+    "ink": "^6.8.0",
+    "ioredis": "^5.10.1",
+    "js-cookie": "^3.0.7",
+    "js-yaml": "^4.1.1",
+    "jwt-decode": "^4.0.0",
+    "latest-version": "^9.0.0",
+    "lodash": "^4.18.1",
+    "mermaid": "^11.15.0",
+    "negotiator": "^1.0.0",
+    "open": "^11.0.0",
+    "ora": "^9.4.0",
+    "pluralize": "^8.0.0",
+    "postgres": "^3.4.9",
+    "protobufjs": "^8.4.0",
+    "qrcode": "^1.5.4",
+    "react": "19.2.4",
+    "react-copy-to-clipboard": "^5.1.1",
+    "react-datepicker": "^9.1.0",
+    "react-device-detect": "^2.2.3",
+    "react-dom": "19.2.4",
+    "react-icons": "^5.6.0",
+    "react-refresh": "^0.18.0",
+    "react-server-dom-webpack": "^19.2.6",
+    "react-simple-pull-to-refresh": "^1.3.4",
+    "react-spring": "^9.7.5",
+    "scheduler": "^0.27.0",
+    "sharp": "^0.34.5",
+    "ssh2": "^1.17.0",
+    "subset-font": "^2.5.0",
+    "tailwind-scrollbar": "^4.0.2",
+    "tailwindcss": "^4.3.0",
+    "typescript": "^6.0.3",
+    "uuid": "^13.0.2"
+  },
+  "devDependencies": {
+    "@capacitor/cli": "^8.3.4"
+  },
+  "bun": {
+    "platform": "bun"
+  },
+  "engines": {
+    "bun": ">=1.3.13"
+  },
+  "main": "./index.ts"
 }