akanjs 2.0.4 → 2.0.5-canary.0

package/cli/index.js

@@ -10093,7 +10093,7 @@ class PackageRunner extends runner("package") {
     const scanner = await TypeScriptDependencyScanner.from(pkg);
     const { npmDeps, npmDevDeps, missingDeps } = await scanner.getPackageBuildDependencies(pkg.name);
     const packageRuntimeDependencies = { akanjs: ["daisyui"] };
-    const packageRuntimeDevDependencies = { akanjs: ["@biomejs/biome"] };
+    const packageRuntimeDevDependencies = { akanjs: ["@biomejs/biome", "@types/bun"] };
     const forcedRuntimeDeps = packageRuntimeDependencies[pkg.name] ?? [];
     const forcedRuntimeDevDeps = packageRuntimeDevDependencies[pkg.name] ?? [];
     const packageRuntimeDeps = [...new Set([...npmDeps, ...forcedRuntimeDeps])];

package/cli/package/package.runner.ts

@@ -39,7 +39,7 @@ export class PackageRunner extends runner("package") {
     const scanner = await TypeScriptDependencyScanner.from(pkg);
     const { npmDeps, npmDevDeps, missingDeps } = await scanner.getPackageBuildDependencies(pkg.name);
     const packageRuntimeDependencies: Record<string, string[]> = { akanjs: ["daisyui"] };
-    const packageRuntimeDevDependencies: Record<string, string[]> = { akanjs: ["@biomejs/biome"] };
+    const packageRuntimeDevDependencies: Record<string, string[]> = { akanjs: ["@biomejs/biome", "@types/bun"] };
     const forcedRuntimeDeps = packageRuntimeDependencies[pkg.name] ?? [];
     const forcedRuntimeDevDeps = packageRuntimeDevDependencies[pkg.name] ?? [];
     const packageRuntimeDeps = [...new Set([...npmDeps, ...forcedRuntimeDeps])];

package/cli/templates/app/env/env.server.develop.ts.template

@@ -5,5 +5,4 @@ import type { ModulesOptions } from "../lib/option";
 export const env: ModulesOptions = {
   ...getEnv(),
   hostname: null,
-  redis: {},
 };

package/cli/templates/app/env/env.server.local.ts.template

@@ -5,7 +5,6 @@ import type { ModulesOptions } from "../lib/option";
 export const env: ModulesOptions = {
   ...getEnv(),
   hostname: null,
-  redis: {},
   security: {
     verifies: [["password", "phone", "naver", "kakao"]],
     sso: {},

package/cli/templates/app/env/env.server.main.ts.template

@@ -5,5 +5,4 @@ import type { ModulesOptions } from "../lib/option";
 export const env: ModulesOptions = {
   ...getEnv(),
   hostname: null,
-  redis: {},
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "2.0.4",
+  "version": "2.0.5-canary.0",
   "sourceType": "module",
   "type": "module",
   "bin": {
@@ -19,103 +19,145 @@
   },
   "exports": {
     ".": {
+      "types": "./types/index.d.ts",
       "import": "./index.ts",
-      "types": "./index.ts",
       "default": "./index.ts"
     },
     "./package.json": "./package.json",
     "./capacitor.base.config": {
+      "types": "./types/devkit/capacitor.base.config.d.ts",
       "import": "./devkit/capacitor.base.config.ts",
-      "types": "./devkit/capacitor.base.config.ts",
       "default": "./devkit/capacitor.base.config.ts"
     },
     "./base": {
+      "types": "./types/base/index.d.ts",
       "import": "./base/index.ts",
-      "types": "./base/index.ts",
       "default": "./base/index.ts"
     },
     "./common": {
+      "types": "./types/common/index.d.ts",
       "import": "./common/index.ts",
-      "types": "./common/index.ts",
       "default": "./common/index.ts"
     },
-    "./common/*": "./common/*",
+    "./common/*": {
+      "types": "./types/common/*.d.ts",
+      "import": "./common/*",
+      "default": "./common/*"
+    },
+    "./common/*.ts": {
+      "types": "./types/common/*.d.ts",
+      "import": "./common/*.ts",
+      "default": "./common/*.ts"
+    },
+    "./common/*.tsx": {
+      "types": "./types/common/*.d.ts",
+      "import": "./common/*.tsx",
+      "default": "./common/*.tsx"
+    },
     "./fetch": {
+      "types": "./types/fetch/index.d.ts",
       "import": "./fetch/index.ts",
-      "types": "./fetch/index.ts",
       "default": "./fetch/index.ts"
     },
     "./document": {
+      "types": "./types/document/index.d.ts",
       "import": "./document/index.ts",
-      "types": "./document/index.ts",
       "default": "./document/index.ts"
     },
     "./signal": {
+      "types": "./types/signal/index.d.ts",
       "import": "./signal/index.ts",
-      "types": "./signal/index.ts",
       "default": "./signal/index.ts"
     },
     "./store": {
+      "types": "./types/store/index.d.ts",
       "import": "./store/index.ts",
-      "types": "./store/index.ts",
       "default": "./store/index.ts"
     },
     "./ui": {
+      "types": "./types/ui/index.d.ts",
       "import": "./ui/index.ts",
-      "types": "./ui/index.ts",
       "default": "./ui/index.ts"
     },
-    "./ui/*": "./ui/*",
+    "./ui/*": {
+      "types": "./types/ui/*.d.ts",
+      "import": "./ui/*",
+      "default": "./ui/*"
+    },
+    "./ui/*.ts": {
+      "types": "./types/ui/*.d.ts",
+      "import": "./ui/*.ts",
+      "default": "./ui/*.ts"
+    },
+    "./ui/*.tsx": {
+      "types": "./types/ui/*.d.ts",
+      "import": "./ui/*.tsx",
+      "default": "./ui/*.tsx"
+    },
     "./client": {
+      "types": "./types/client/index.d.ts",
       "import": "./client/index.ts",
-      "types": "./client/index.ts",
       "default": "./client/index.ts"
     },
     "./webkit": {
+      "types": "./types/webkit/index.d.ts",
       "import": "./webkit/index.ts",
-      "types": "./webkit/index.ts",
       "default": "./webkit/index.ts"
     },
-    "./webkit/*": "./webkit/*",
+    "./webkit/*": {
+      "types": "./types/webkit/*.d.ts",
+      "import": "./webkit/*",
+      "default": "./webkit/*"
+    },
+    "./webkit/*.ts": {
+      "types": "./types/webkit/*.d.ts",
+      "import": "./webkit/*.ts",
+      "default": "./webkit/*.ts"
+    },
+    "./webkit/*.tsx": {
+      "types": "./types/webkit/*.d.ts",
+      "import": "./webkit/*.tsx",
+      "default": "./webkit/*.tsx"
+    },
     "./server": {
+      "types": "./types/server/index.d.ts",
       "import": "./server/index.ts",
-      "types": "./server/index.ts",
       "default": "./server/index.ts"
     },
     "./service": {
+      "types": "./types/service/index.d.ts",
       "import": "./service/index.ts",
-      "types": "./service/index.ts",
       "default": "./service/index.ts"
     },
     "./constant": {
+      "types": "./types/constant/index.d.ts",
       "import": "./constant/index.ts",
-      "types": "./constant/index.ts",
       "default": "./constant/index.ts"
     },
     "./dictionary": {
+      "types": "./types/dictionary/index.d.ts",
       "import": "./dictionary/index.ts",
-      "types": "./dictionary/index.ts",
       "default": "./dictionary/index.ts"
     },
     "./devkit": {
+      "types": "./types/devkit/index.d.ts",
       "import": "./devkit/index.ts",
-      "types": "./devkit/index.ts",
       "default": "./devkit/index.ts"
     },
     "./test": {
+      "types": "./types/test/index.d.ts",
       "import": "./test/index.ts",
-      "types": "./test/index.ts",
       "default": "./test/index.ts"
     },
     "./cli": {
+      "types": "./types/cli/index.d.ts",
       "import": "./cli/index.ts",
-      "types": "./cli/index.ts",
       "default": "./cli/index.ts"
     },
     "./ui/styles.css": "./ui/styles.css",
     "./server/rsc-worker": {
+      "types": "./types/server/rscWorker.d.ts",
       "import": "./server/rscWorker.tsx",
-      "types": "./server/rscWorker.tsx",
       "default": "./server/rscWorker.tsx"
     }
   },
@@ -197,7 +239,8 @@
   },
   "devDependencies": {
     "@biomejs/biome": "2.4.4",
-    "@capacitor/cli": "^8.3.4"
+    "@capacitor/cli": "^8.3.4",
+    "@types/bun": "^1.3.14"
   },
   "bun": {
     "platform": "bun"

package/server/webRouter.ts

@@ -1,7 +1,13 @@
 import fs from "node:fs";
 import path from "node:path";
 import { getEnv } from "akanjs/base";
-import { DEFAULT_AKAN_I18N, getBasePathFromPathname, Logger, parseAkanI18nEnv } from "akanjs/common";
+import {
+  type AkanI18nConfig,
+  DEFAULT_AKAN_I18N,
+  getBasePathFromPathname,
+  Logger,
+  parseAkanI18nEnv,
+} from "akanjs/common";
 import { parseCookieHeader } from "akanjs/fetch";
 import type { AkanMetricsReport } from "akanjs/service";
 import {
@@ -21,6 +27,25 @@ import { createDefaultSitemapXml, getSitemapBasePath } from "./sitemap";
 import { SsrFromRscRenderer } from "./ssrFromRscRenderer";
 import type { BaseBuildArtifact, HttpRoutes, RenderState } from "./types";
 
+const RESERVED_BASE_PATHS = new Set(["admin"]);
+
+export function normalizeRscTargetUrlForHostBasePath(
+  targetUrl: URL,
+  options: { basePath: string | null; i18n: AkanI18nConfig },
+): URL {
+  const { basePath, i18n } = options;
+  if (!basePath) return targetUrl;
+
+  const segments = targetUrl.pathname.split("/").filter(Boolean);
+  const [locale, firstPath] = segments;
+  if (!locale || !i18n.locales.includes(locale)) return targetUrl;
+  if (firstPath === basePath || RESERVED_BASE_PATHS.has(firstPath ?? "")) return targetUrl;
+
+  const normalized = new URL(targetUrl);
+  normalized.pathname = `/${[locale, basePath, ...segments.slice(1)].join("/")}`;
+  return normalized;
+}
+
 export interface SsrRoutesResult {
   renderEnvRoutes: HttpRoutes;
   hmrHub: HmrWsHub | null;
@@ -198,11 +223,19 @@ export class WebRouter {
           /** After TLS/pass-through proxies Bun often sees internal http origins; forwarded headers preserve the browser origin for same-origin checks. */
           const clientOrigin = WebRouter.#clientFacingOrigin(req);
           const target = reqUrl.searchParams.get("url");
-          const targetUrl = target ? new URL(target, clientOrigin) : reqUrl;
+          const rawTargetUrl = target ? new URL(target, clientOrigin) : reqUrl;
+          const basePath =
+            req.headers.get("x-base-path") ?? WebRouter.#basePathForRequestHost(req, this.#artifact.subRoutes);
+          const targetUrl = normalizeRscTargetUrlForHostBasePath(rawTargetUrl, {
+            basePath,
+            i18n: this.#artifact.i18n,
+          });
           if (!WebRouter.#isTrustedRscTarget(clientOrigin, targetUrl))
             return new Response("Bad Request", { status: 400 });
           const manifest = await this.#ensureRoute(targetUrl);
-          const rscReq = new Request(targetUrl, { method: "GET", headers: req.headers });
+          const rscHeaders = new Headers(req.headers);
+          if (basePath) rscHeaders.set("x-base-path", basePath);
+          const rscReq = new Request(targetUrl, { method: "GET", headers: rscHeaders });
           const result = await this.#rsc.renderWithMeta(rscReq, { clientManifest: manifest.clientManifest });
           if (result.type === "redirect") return WebRouter.#rscRedirectResponse(result.location, result.method);
           if (result.type === "not-found") return WebRouter.#rscRedirectResponse("/404", "replace");

package/types/base/base.d.ts

@@ -0,0 +1,53 @@
+import type { Cls } from ".";
+import { Float, Int } from "./primitiveRegistry.d.ts";
+export type EnumInstance<RefName extends string = string, T = string | number> = Cls<{
+    refName: RefName;
+    value: T;
+}, {
+    refName: RefName;
+    type: StringConstructor | typeof Int | typeof Float;
+    values: readonly T[];
+    valueMap: Map<T, number>;
+    has: (value: T) => boolean;
+    indexOf: (value: T) => number;
+    find: (callback: (value: T, index: number, array: readonly T[]) => boolean) => T;
+    findIndex: (callback: (value: T, index: number, array: readonly T[]) => boolean) => number;
+    filter: (callback: (value: T, index: number, array: readonly T[]) => boolean) => T[];
+    map: <R>(callback: (value: T, index: number, array: readonly T[]) => R) => R[];
+    forEach: (callback: (value: T, index: number, array: readonly T[]) => void) => void;
+}>;
+/** Returns true when a class was created by `enumOf`. */
+export declare const isEnum: (enumRef: Cls) => boolean;
+/** Creates a typed scalar enum class from a readonly list of string or number values. */
+export declare const enumOf: <RefName extends string, T = string | number>(refName: RefName, values: readonly T[]) => EnumInstance<RefName, T>;
+/** Id-keyed list helper used for light model collections and immutable-style list updates. */
+export declare class DataList<Light extends {
+    id: string;
+}> {
+    #private;
+    length: number;
+    values: Light[];
+    constructor(data?: Light[] | DataList<Light>);
+    indexOf(id: string): number;
+    set(value: Light): this;
+    delete(id: string): this;
+    get(id: string): Light | undefined;
+    at(idx: number): Light | undefined;
+    pickAt(idx: number): Light;
+    pick(id: string): Light;
+    has(id: string): boolean;
+    find(fn: (value: Light, idx: number) => boolean): Light | undefined;
+    findIndex(fn: (value: Light, idx: number) => boolean): number;
+    some(fn: (value: Light, idx: number) => boolean): boolean;
+    every(fn: (value: Light, idx: number) => boolean): boolean;
+    forEach(fn: (value: Light, idx: number) => void): void;
+    map<T>(fn: (value: Light, idx: number) => T): T[];
+    flatMap<T>(fn: (value: Light, idx: number, array: Light[]) => T | readonly T[]): T[];
+    sort(fn: (a: Light, b: Light) => number): DataList<Light>;
+    filter(fn: (value: Light, idx: number) => boolean): DataList<Light>;
+    reduce<T>(fn: (acc: T, value: Light, idx: number) => T, initialValue: T): T;
+    slice(start: number, end?: number): DataList<Light>;
+    save(): DataList<Light>;
+    [Symbol.iterator](): ArrayIterator<Light>;
+}
+export declare const logo = "\n     _    _                  _     \n    / \\  | | ____ _ _ __    (_)___ \n   / _ \\ | |/ / _' | '_ \\   | / __|\n  / ___ \\|   < (_| | | | |_ | \\__ \\\n /_/   \\_\\_|\\_\\__,_|_| |_(_)/ |___/\n                          |__/      \n? See more details on docs  https://www.akanjs.com/docs\n\u2605 Star Akanjs on GitHub     https://github.com/akan-team/akanjs\n\n";

package/types/base/baseEnv.d.ts

@@ -0,0 +1,68 @@
+export type Environment = "testing" | "debug" | "develop" | "main" | "local";
+export type DatabaseMode = "single" | "multiple" | "cluster";
+export interface BaseEnv {
+    repoName: string;
+    serveDomain: string;
+    appName: string;
+    environment: Environment;
+    operationMode: "local" | "edge" | "cloud" | "module";
+    tunnelUsername: string;
+    tunnelPassword: string;
+    databaseMode?: DatabaseMode;
+}
+export type BackendEnv = BaseEnv & {
+    hostname?: string | null;
+    port?: number;
+    database?: {
+        mode?: DatabaseMode;
+        driver?: "sqlite" | "libsql" | "postgres";
+        sqlite?: {
+            filePath?: string;
+            journalMode?: string;
+            busyTimeoutMs?: number;
+            synchronous?: string;
+            foreignKeys?: boolean;
+            cacheSize?: number;
+            tempStore?: string;
+        };
+        libsql?: {
+            url?: string;
+            authToken?: string;
+        };
+        postgres?: {
+            url?: string;
+            host?: string;
+            port?: number;
+            database?: string;
+            user?: string;
+            password?: string;
+        };
+    };
+    solid?: {
+        filePath?: string;
+        journalMode?: string;
+        busyTimeoutMs?: number;
+        synchronous?: string;
+        cleanupIntervalMs?: number;
+        queuePollIntervalMs?: number;
+        queueLeaseMs?: number;
+    };
+    onCleanup?: () => Promise<void>;
+};
+export type ClientEnv = BaseEnv & {
+    side: "server" | "client";
+    renderMode: "ssr" | "csr";
+    websocket: boolean;
+    clientHost: string;
+    clientPort: number;
+    clientHttpProtocol: "http:" | "https:";
+    clientHttpUri: string;
+    serverHost: string;
+    serverPort: number;
+    serverHttpProtocol: "http:" | "https:";
+    serverHttpUri: string;
+    serverWsProtocol: "ws:" | "wss:";
+    serverWsUri: string;
+};
+/** Reads and caches Akan runtime environment values from process/browser environment settings. */
+export declare const getEnv: () => ClientEnv;

package/types/base/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./base.d.ts";
+export * from "./baseEnv.d.ts";
+export * from "./primitiveRegistry.d.ts";
+export * from "./symbols.d.ts";
+export * from "./types.d.ts";
+export * from "./utils.d.ts";

package/types/base/primitiveRegistry.d.ts

@@ -0,0 +1,134 @@
+import dayjsLib, { type Dayjs } from "dayjs";
+import type { Cls } from "./types.d.ts";
+export type { Dayjs };
+/** Shared dayjs factory re-export used by Akan documents, services, stores, and UI. */
+export declare const dayjs: typeof dayjsLib;
+/** Registry that maps Akan primitive scalar names to their runtime scalar classes. */
+export declare class PrimitiveRegistry {
+    #private;
+    static register(scalar: typeof PrimitiveScalar, { overwrite }?: {
+        overwrite?: boolean | undefined;
+    }): void;
+    static get(name: string): typeof PrimitiveScalar;
+    static getName(scalar: typeof PrimitiveScalar): string;
+    static has(modelRef: Cls): boolean;
+    static hasName(name: string): boolean;
+    static getNames(): string[];
+    static getAll(): (typeof PrimitiveScalar)[];
+}
+export declare const PRIMITIVE_SERVER_VALUE: unique symbol;
+export declare const PRIMITIVE_CLIENT_VALUE: unique symbol;
+export declare const PRIMITIVE_DEFAULT_VALUE: unique symbol;
+export declare const PRIMITIVE_EXAMPLE_VALUE: unique symbol;
+export type PrimitiveValue = string | number | boolean | Dayjs | Date | null | undefined;
+export declare class PrimitiveScalar {
+    static refName: string;
+    static [PRIMITIVE_SERVER_VALUE]: unknown;
+    static [PRIMITIVE_CLIENT_VALUE]: unknown;
+    static [PRIMITIVE_DEFAULT_VALUE]: unknown;
+    static [PRIMITIVE_EXAMPLE_VALUE]: unknown;
+    static validate(value: PrimitiveValue): boolean;
+    static parseValue(value: PrimitiveValue): PrimitiveValue;
+    static serializeValue(value: PrimitiveValue): PrimitiveValue;
+    static _parse(this: typeof PrimitiveScalar, input: PrimitiveValue, { optional }?: {
+        optional?: boolean;
+    }): PrimitiveValue;
+    static _serialize(this: typeof PrimitiveScalar, value: PrimitiveValue, { optional }?: {
+        optional?: boolean;
+    }): PrimitiveValue;
+    static _checkValue(this: typeof PrimitiveScalar, value: PrimitiveValue, { optional }?: {
+        optional?: boolean;
+    }): void;
+}
+/** Integer primitive scalar. Accepts safe integer numbers after parsing. */
+export declare class Int extends PrimitiveScalar {
+    static refName: "Int";
+    static [PRIMITIVE_SERVER_VALUE]: number;
+    static [PRIMITIVE_CLIENT_VALUE]: number;
+    static [PRIMITIVE_DEFAULT_VALUE]: number;
+    static [PRIMITIVE_EXAMPLE_VALUE]: number;
+    static validate(value: string | number): boolean;
+    static parseValue(input: string | number): number;
+    static serializeValue(value: number): number;
+}
+/** Floating point primitive scalar. Accepts finite numbers after parsing. */
+export declare class Float extends PrimitiveScalar {
+    static refName: "Float";
+    static [PRIMITIVE_SERVER_VALUE]: number;
+    static [PRIMITIVE_CLIENT_VALUE]: number;
+    static [PRIMITIVE_DEFAULT_VALUE]: number;
+    static [PRIMITIVE_EXAMPLE_VALUE]: number;
+    static validate(value: string | number): boolean;
+    static parseValue(input: string | number): number;
+    static serializeValue(value: number): number;
+}
+/** 24-character hexadecimal id primitive used by Akan document and signal models. */
+export declare class ID extends PrimitiveScalar {
+    static refName: "ID";
+    static [PRIMITIVE_SERVER_VALUE]: string;
+    static [PRIMITIVE_CLIENT_VALUE]: string;
+    static [PRIMITIVE_DEFAULT_VALUE]: string;
+    static [PRIMITIVE_EXAMPLE_VALUE]: string;
+    static validate(value: string): boolean;
+    static parseValue(input: string): string;
+    static serializeValue(value: string): string;
+    static _checkValue(value: PrimitiveValue, options?: {
+        optional?: boolean;
+    }): void;
+}
+/** Open object primitive for intentionally flexible payloads or metadata blobs. */
+export declare class Any extends PrimitiveScalar {
+    static refName: "Any";
+    static [PRIMITIVE_DEFAULT_VALUE]: object | null;
+    static [PRIMITIVE_EXAMPLE_VALUE]: object;
+}
+export declare class Upload extends PrimitiveScalar {
+    static refName: "Upload";
+    static [PRIMITIVE_SERVER_VALUE]: File;
+    static [PRIMITIVE_CLIENT_VALUE]: File;
+    static [PRIMITIVE_DEFAULT_VALUE]: File | null;
+    static [PRIMITIVE_EXAMPLE_VALUE]: string;
+    __TEMP_TYPE__: "Upload";
+}
+declare global {
+    interface StringConstructor {
+        refName: "String";
+        [PRIMITIVE_SERVER_VALUE]: string;
+        [PRIMITIVE_CLIENT_VALUE]: string;
+        [PRIMITIVE_DEFAULT_VALUE]: string;
+        [PRIMITIVE_EXAMPLE_VALUE]: string;
+        validate(value: string): boolean;
+        parseValue(input: string): string;
+        serializeValue(value: string): string;
+        _parse(input: string): string;
+        _serialize(value: string): string;
+        _checkValue(value: string): void;
+    }
+    interface BooleanConstructor {
+        refName: "Boolean";
+        [PRIMITIVE_SERVER_VALUE]: boolean;
+        [PRIMITIVE_CLIENT_VALUE]: boolean;
+        [PRIMITIVE_DEFAULT_VALUE]: boolean;
+        [PRIMITIVE_EXAMPLE_VALUE]: boolean;
+        validate(value: boolean): boolean;
+        parseValue(input: boolean): boolean;
+        serializeValue(value: boolean): boolean;
+        _parse(input: boolean): boolean;
+        _serialize(value: boolean): boolean;
+        _checkValue(value: boolean): void;
+    }
+    interface DateConstructor {
+        refName: "Date";
+        [PRIMITIVE_SERVER_VALUE]: Dayjs;
+        [PRIMITIVE_CLIENT_VALUE]: Dayjs;
+        [PRIMITIVE_DEFAULT_VALUE]: Dayjs;
+        [PRIMITIVE_EXAMPLE_VALUE]: string;
+        validate(value: Date): boolean;
+        parseValue(input: Date): Dayjs;
+        serializeValue(value: Dayjs | Date): Date;
+        _parse(input: Date): Dayjs;
+        _serialize(value: Dayjs | Date): Date;
+        _checkValue(value: Date): void;
+    }
+}
+export type DefaultPrimitiveName = "String" | "Boolean" | "Date" | "Int" | "Float" | "ID" | "Any" | "Upload";

package/types/base/symbols.d.ts

@@ -0,0 +1,11 @@
+export declare const FIELD_META: unique symbol;
+export declare const SLICE_META: unique symbol;
+export declare const FILTER_META: unique symbol;
+export declare const LOADER_META: unique symbol;
+export declare const INJECT_META: unique symbol;
+export declare const ENDPOINT_META: unique symbol;
+export declare const INTERNAL_META: unique symbol;
+export declare const STATE_META: unique symbol;
+export declare const STATE_INIT_META: unique symbol;
+export declare const STATE_DERIVED_META: unique symbol;
+export declare const ACTION_META: unique symbol;

package/types/base/types.d.ts

@@ -0,0 +1,68 @@
+import type { Dayjs } from "dayjs";
+export type SshOptions = {
+    host: string;
+    port: number;
+    username: string;
+    password: string;
+    dstPort?: number;
+};
+export type Cls<T = unknown, Statics = unknown> = (new (...args: never[]) => T) & Statics;
+export type BufferLike = string | Buffer | DataView | number | ArrayBufferView | Uint8Array | ArrayBuffer | SharedArrayBuffer | readonly unknown[] | readonly number[];
+export type GetObject<T> = {
+    [K in keyof T as K extends "prototype" ? never : K]: T[K];
+};
+export type OptionOf<Obj> = Partial<{
+    [K in keyof Obj]: Obj[K] | null;
+}>;
+export type UnCls<T> = T extends new (...args: infer _Args) => infer U ? U : never;
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type GetStateObject<T> = {
+    [K in keyof T as T[K] extends (...args: never[]) => unknown ? never : K extends "prototype" ? never : K]: T[K];
+};
+export type GetActionObject<T> = {
+    [K in keyof T as T[K] extends (...args: never[]) => unknown ? (K extends "prototype" ? never : K) : never]: T[K];
+};
+export type PromiseOrObject<T> = T | Promise<T>;
+type MergeObjectValues<T> = T extends Record<string, infer V> ? (V extends object ? V : never) : never;
+type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+export type MergedValues<T> = UnionToIntersection<MergeObjectValues<T>>;
+export type Assign<A, B> = Omit<A, keyof B> & B;
+export type ObjectAssign<Objects extends object[], Acc = unknown> = Objects extends [
+    infer First extends object,
+    ...infer Rest extends object[]
+] ? ObjectAssign<Rest, Assign<Acc, First>> : Acc;
+export type MergeAll<T extends object[], Acc = unknown> = T extends [
+    infer First extends object,
+    ...infer Rest extends object[]
+] ? MergeAll<Rest, Acc & First> : Acc;
+export type MergeAllActionTypes<T extends Cls[], OmitKey extends string = never, Acc = unknown> = T extends [
+    infer First extends Cls,
+    ...infer Rest extends Cls[]
+] ? Rest extends [] ? Acc & Omit<GetActionObject<UnCls<First>>, OmitKey> : MergeAllActionTypes<Rest, OmitKey, Acc & Omit<UnCls<First>, OmitKey>> : Acc;
+export type MergeAllTypes<T extends Cls[], OmitKey extends string = never, Acc = unknown> = T extends [
+    infer First extends Cls,
+    ...infer Rest extends Cls[]
+] ? MergeAllTypes<Rest, OmitKey, Acc & Omit<UnCls<First>, OmitKey>> : Acc;
+export type MergeAllKeyOfTypes<T extends Cls<object>[], Key extends PropertyKey, Acc = unknown> = T extends [
+    infer First extends Cls<object>,
+    ...infer Rest extends Cls<object>[]
+] ? Key extends keyof UnCls<First> ? MergeAllKeyOfTypes<Rest, Key, Acc & UnCls<First>[Key]> : MergeAllKeyOfTypes<Rest, Key, Acc> : Acc;
+export type MergeAllKeyOfObjects<T extends object[], Key extends PropertyKey, Acc = unknown> = T extends [
+    infer First extends object,
+    ...infer Rest extends object[]
+] ? Key extends keyof First ? MergeAllKeyOfObjects<Rest, Key, Acc & First[Key]> : MergeAllKeyOfObjects<Rest, Key, Acc> : Acc;
+export type MergeAllDoubleKeyOfObjects<T extends object[], Key extends PropertyKey, SubKey extends PropertyKey, Acc = unknown> = T extends [infer First extends object, ...infer Rest extends object[]] ? Key extends keyof First ? First[Key] extends object ? SubKey extends keyof First[Key] ? MergeAllDoubleKeyOfObjects<Rest, Key, SubKey, Acc & First[Key][SubKey]> : MergeAllDoubleKeyOfObjects<Rest, Key, SubKey, Acc> : MergeAllDoubleKeyOfObjects<Rest, Key, SubKey, Acc> : MergeAllDoubleKeyOfObjects<Rest, Key, SubKey, Acc> : Acc;
+export type Primitive = string | number | boolean | null | undefined;
+export type NestedKeysWithAllowed<T, Allowed = Primitive> = T extends Primitive ? never : T extends unknown[] ? never : T extends (...args: never[]) => unknown ? never : {
+    [K in keyof T & string]: T[K] extends Allowed ? K : T[K] extends Dayjs ? never : T[K] extends readonly unknown[] ? never : T[K] extends (...args: never[]) => unknown ? never : T[K] extends object ? K | `${K}.${NestedKeysWithAllowed<T[K], Allowed>}` : never;
+}[keyof T & string];
+export type SingleValue<Value> = Value extends (infer V)[] ? SingleValue<V> : Value;
+export type StrArrToObject<Arr, Value> = Arr extends [infer First, ...infer Rest] ? {
+    [K in First & string]: Value;
+} & StrArrToObject<Rest, Value> : unknown;
+export type GetValueOfKey<Model, Key extends string, Fallback = never> = Model extends {
+    [key in Key]: unknown;
+} ? Model[Key] : Fallback;
+export {};

package/types/base/utils.d.ts

@@ -0,0 +1,4 @@
+export declare const getNonArrayModel: <T>(arraiedModel: T | T[]) => [T, number];
+export declare const arraiedModel: <T = unknown>(modelRef: T, arrDepth?: number) => T | T[];
+export type ApplyFnToArrayObjectsResult<Input, Output> = Input extends readonly (infer Item)[] ? ApplyFnToArrayObjectsResult<Item, Output>[] : Output;
+export declare const applyFnToArrayObjects: <Input, Fn extends (arg: never) => unknown>(arraiedData: Input, fn: Fn) => ApplyFnToArrayObjectsResult<Input, ReturnType<Fn>>;

package/types/base.d.ts

@@ -0,0 +1 @@
+export * from "./base/index.d.ts";

package/types/cli/application/application.command.d.ts

@@ -0,0 +1,7 @@
+import { ApplicationScript } from "./application.script";
+declare const ApplicationCommand_base: import("akanjs/devkit").CommandCls<{
+    applicationScript: ApplicationScript;
+}, "applicationCommand">;
+export declare class ApplicationCommand extends ApplicationCommand_base {
+}
+export {};