@emeryld/rrroutes-export 1.1.1 → 1.1.2

package/dist/inspection/diagnostics.d.ts

@@ -0,0 +1,8 @@
+import type { InspectionDiagnostic } from '../snapshot/types';
+export declare class InspectionDiagnostics {
+    #private;
+    add(diagnostic: InspectionDiagnostic): void;
+    list(options?: {
+        includeInfo?: boolean;
+    }): InspectionDiagnostic[];
+}

package/dist/inspection/inspect-clients.d.ts

@@ -0,0 +1,9 @@
+import { type RouteKey } from '@emeryld/rrroutes-contract';
+import type { ClientResourceInspection, ClientRouteInspection } from '../snapshot/types';
+import type { InspectionDiagnostics } from './diagnostics';
+import { type NormalizedClientInput } from './normalize-clients';
+export type ClientInspectionResult = {
+    clients: Readonly<Record<string, ClientResourceInspection>>;
+    byRoute: Readonly<Record<RouteKey, readonly ClientRouteInspection[]>>;
+};
+export declare function inspectClients(inputs: readonly NormalizedClientInput[], diagnostics: InspectionDiagnostics): ClientInspectionResult;

package/dist/inspection/inspect-contract.d.ts

@@ -0,0 +1,8 @@
+import type { AnyLeafLowProfile, RouteKey } from '@emeryld/rrroutes-contract';
+import { exportFinalizedLeaves } from '../exportFinalizedLeaves';
+import type { ContractRouteInspection, SourceInspectionOptions } from '../snapshot/types';
+export type ContractInspectionResult = {
+    routes: Readonly<Record<RouteKey, ContractRouteInspection>>;
+    sourceExtraction?: Awaited<ReturnType<typeof exportFinalizedLeaves>>['_meta']['sourceExtraction'];
+};
+export declare function inspectContractRoutes(leaves: readonly AnyLeafLowProfile[], source: SourceInspectionOptions | undefined, includeSource: boolean): Promise<ContractInspectionResult>;

package/dist/inspection/inspect-server.d.ts

@@ -0,0 +1,8 @@
+import type { RouteKey } from '@emeryld/rrroutes-contract';
+import type { ServerRouteInspection, ServerRuntimeInspection, SupportedServerInput } from '../snapshot/types';
+import type { InspectionDiagnostics } from './diagnostics';
+export type ServerInspectionResult = {
+    servers: Readonly<Record<string, ServerRuntimeInspection>>;
+    byRoute: Readonly<Record<RouteKey, ServerRouteInspection>>;
+};
+export declare function inspectServer(input: SupportedServerInput | undefined, diagnostics: InspectionDiagnostics): ServerInspectionResult;

package/dist/inspection/inspect-sockets.d.ts

@@ -0,0 +1,4 @@
+import type { SocketRuntimeInspection } from '../snapshot/types';
+import type { InspectionDiagnostics } from './diagnostics';
+import type { NormalizedSocketInput } from './normalize-sockets';
+export declare function inspectSockets(inputs: readonly NormalizedSocketInput[], includeLive: boolean, diagnostics: InspectionDiagnostics): Readonly<Record<string, SocketRuntimeInspection>>;

package/dist/inspection/join-routes.d.ts

@@ -0,0 +1,10 @@
+import type { RouteKey } from '@emeryld/rrroutes-contract';
+import type { ClientRouteInspection, ContractRouteInspection, InspectionDiagnostic, RouteInspection, ServerRouteInspection, ServerRuntimeInspection } from '../snapshot/types';
+export declare function joinRouteInspections(args: {
+    contract: Readonly<Record<RouteKey, ContractRouteInspection>>;
+    clients: Readonly<Record<RouteKey, readonly ClientRouteInspection[]>>;
+    server: Readonly<Record<RouteKey, ServerRouteInspection>>;
+    servers: Readonly<Record<string, ServerRuntimeInspection>>;
+    serverSupplied: boolean;
+    diagnostics: InspectionDiagnostic[];
+}): Readonly<Record<RouteKey, RouteInspection>>;

package/dist/inspection/native.d.ts

@@ -0,0 +1,4 @@
+export declare function asRecord(value: unknown): Record<PropertyKey, unknown> | undefined;
+export declare function readNativeInspection(value: unknown): Record<PropertyKey, unknown> | undefined;
+export declare function optionalString(value: unknown): string | undefined;
+export declare function optionalBoolean(value: unknown): boolean | undefined;

package/dist/inspection/normalize-clients.d.ts

@@ -0,0 +1,8 @@
+import type { SupportedClientsInput, SupportedEndpointClient } from '../snapshot/types';
+export type NormalizedClientInput = {
+    value: object;
+    registeredName?: string;
+    index: number;
+};
+export declare function normalizeClientsInput(endpointClient?: SupportedEndpointClient, allClients?: SupportedClientsInput): readonly NormalizedClientInput[];
+export declare function looksLikeClientEndpoint(value: unknown): boolean;

package/dist/inspection/normalize-routes.d.ts

@@ -0,0 +1,3 @@
+import type { AnyLeafLowProfile } from '@emeryld/rrroutes-contract';
+import type { SupportedRoutesInput } from '../snapshot/types';
+export declare function normalizeRoutesInput(input: SupportedRoutesInput): readonly AnyLeafLowProfile[];

package/dist/inspection/normalize-sockets.d.ts

@@ -0,0 +1,7 @@
+import type { SocketRuntime, SupportedSocketsInput } from '../snapshot/types';
+export type NormalizedSocketInput = {
+    value: SocketRuntime;
+    registeredName?: string;
+    index: number;
+};
+export declare function normalizeSocketsInput(input?: SupportedSocketsInput): readonly NormalizedSocketInput[];

package/dist/inspection/serializable.d.ts

@@ -0,0 +1,3 @@
+import type { JsonValue } from '../snapshot/types';
+export declare function serializeSelectedMetadata(value: unknown, depth?: number): JsonValue | undefined;
+export declare function serializeClientBuildOptions(value: unknown): Record<string, JsonValue>;

package/dist/runtime.d.ts

@@ -0,0 +1,16 @@
+import type { CheckpointService } from './checkpoint/types';
+import type { DiffOptions, RRRoutesChangeSet } from './diff/types';
+import { type WriteChangeSetOptions, type WriteSnapshotOptions } from './files/write';
+import { createExpressRouter, type InspectorExpressOptions } from './adapters/express';
+import type { HttpHandler, InspectorHttpOptions } from './http/types';
+import type { CreateRRRoutesExportRuntimeOptions, InspectOptions, RRRoutesSnapshot } from './snapshot/types';
+export interface RRRoutesExportRuntime {
+    inspect(options?: InspectOptions): Promise<RRRoutesSnapshot>;
+    diff(before: RRRoutesSnapshot, after?: RRRoutesSnapshot, options?: DiffOptions): Promise<RRRoutesChangeSet>;
+    checkpoints: CheckpointService;
+    createHttpHandler(options?: InspectorHttpOptions): HttpHandler;
+    createExpressRouter(options?: Omit<InspectorExpressOptions, 'runtime'>): ReturnType<typeof createExpressRouter>;
+    writeSnapshot(options: WriteSnapshotOptions): Promise<RRRoutesSnapshot>;
+    writeChangeSet(changeSet: RRRoutesChangeSet, options: WriteChangeSetOptions): Promise<void>;
+}
+export declare function createRRRoutesExportRuntime(options: CreateRRRoutesExportRuntimeOptions): RRRoutesExportRuntime;

package/dist/serializeLeafContract.d.ts

@@ -10,6 +10,7 @@ export type ContractLeafSchemas = {
 };
 export type SerializedLeafContract = {
     key: string;
+    id?: string;
     method: AnyLeafLowProfile['method'];
     path: string;
     cfg: {

package/dist/snapshot/build.d.ts

@@ -0,0 +1,2 @@
+import type { CreateRRRoutesExportRuntimeOptions, InspectOptions, RRRoutesSnapshot } from './types';
+export declare function buildRRRoutesSnapshot(options: CreateRRRoutesExportRuntimeOptions, inspectOptions?: InspectOptions): Promise<RRRoutesSnapshot>;

package/dist/snapshot/canonicalize.d.ts

@@ -0,0 +1,6 @@
+import type { JsonValue, RRRoutesSnapshot } from './types';
+export declare function canonicalizeJson(value: unknown): JsonValue;
+export declare function canonicalSnapshotStructure(snapshot: RRRoutesSnapshot, options?: {
+    includeLive?: boolean;
+}): JsonValue;
+export declare function stableStringify(value: unknown): string;

package/dist/snapshot/hash.d.ts

@@ -0,0 +1,5 @@
+import type { RRRoutesSnapshot } from './types';
+export declare function hashCanonicalValue(value: unknown): string;
+export declare function hashRRRoutesSnapshot(snapshot: RRRoutesSnapshot, options?: {
+    includeLive?: boolean;
+}): string;

package/dist/snapshot/types.d.ts

@@ -0,0 +1,287 @@
+import type { AnyLeafLowProfile, FinalizedRegistry, RRRoutesInspectionJsonValue, RouteKey, RouteResource } from '@emeryld/rrroutes-contract';
+import type { FlatSchemaMap } from '../flattenSchema';
+import type { LeafSourceByKey } from '../extractLeafSourceByAst';
+import type { SerializedLeafContract } from '../serializeLeafContract';
+import type { SerializableSchema } from '../schemaIntrospection';
+import type { ChangeSetRetention, CheckpointRetention } from '../checkpoint/types';
+import type { InspectionStorage } from '../storage/types';
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = RRRoutesInspectionJsonValue;
+export type IdentityStability = 'stable' | 'positional';
+export type SupportedRoutesInput = FinalizedRegistry<readonly AnyLeafLowProfile[]> | readonly AnyLeafLowProfile[] | RouteResource;
+export type InspectableClientResource = object;
+export type SupportedEndpointClient = object;
+export type SupportedClientsInput = Readonly<Record<string, InspectableClientResource>> | readonly InspectableClientResource[];
+export type SocketRuntime = object;
+export type SupportedSocketsInput = Readonly<Record<string, SocketRuntime>> | readonly SocketRuntime[] | SocketRuntime;
+export type SupportedServerInput = object;
+export type RuntimeSnapshotMetaInput = {
+    application?: string;
+    environment?: string;
+    version?: string;
+    commit?: string;
+    instanceId?: string;
+};
+export type SourceInspectionOptions = {
+    include?: boolean;
+    modulePath?: string;
+    exportName?: string;
+    tsconfigPath?: string;
+};
+export type DiagnosticOptions = {
+    includeInfo?: boolean;
+};
+export interface CreateRRRoutesExportRuntimeOptions {
+    endpointClient?: SupportedEndpointClient;
+    allRoutes: SupportedRoutesInput;
+    allClients?: SupportedClientsInput;
+    sockets?: SupportedSocketsInput;
+    server?: SupportedServerInput;
+    meta?: RuntimeSnapshotMetaInput;
+    source?: SourceInspectionOptions;
+    diagnostics?: DiagnosticOptions;
+    storage?: InspectionStorage;
+    checkpoints?: {
+        scope?: string;
+        retention?: CheckpointRetention;
+        changeSetRetention?: ChangeSetRetention;
+    };
+}
+export type InspectOptions = {
+    includeLive?: boolean;
+    includeSource?: boolean;
+};
+export type InspectionDiagnosticSeverity = 'info' | 'warning' | 'error';
+export interface InspectionDiagnostic {
+    code: string;
+    severity: InspectionDiagnosticSeverity;
+    entity?: {
+        routeKey?: RouteKey;
+        client?: string;
+        server?: string;
+        socket?: string;
+        [key: string]: string | undefined;
+    };
+    message: string;
+}
+export interface RRRoutesSnapshotMeta {
+    capturedAt: string;
+    snapshotHash: string;
+    application?: string;
+    environment?: string;
+    version?: string;
+    commit?: string;
+    instanceId?: string;
+    packageVersions: {
+        contract?: string;
+        client?: string;
+        server?: string;
+        export?: string;
+    };
+    sourceExtraction?: {
+        mode: 'ast';
+        enabled: boolean;
+        modulePath?: string;
+        exportName?: string;
+        tsconfigPath?: string;
+        resolvedLeafCount: number;
+        reason?: string;
+    };
+}
+export interface RRRoutesSnapshotCapabilities {
+    contract: true;
+    client: boolean;
+    server: boolean;
+    socket: boolean;
+    live: boolean;
+    source: boolean;
+}
+export interface ContractRouteInspection {
+    serializedLeaf: SerializedLeafContract;
+    schemaFlat: FlatSchemaMap;
+    source?: LeafSourceByKey[string];
+    fingerprint: string;
+}
+export interface SerializableClientBuildOptions {
+    readonly [key: string]: JsonValue;
+}
+export interface ClientAugmentInspection {
+    identity: string;
+    id?: string;
+    name?: string;
+    kind?: string;
+    options?: JsonValue;
+    order: number;
+    identityStability: IdentityStability;
+}
+export interface ClientSocketConnectionInspection {
+    identity: string;
+    id?: string;
+    name?: string;
+    events: readonly string[];
+    roomStrategy?: JsonValue;
+    cacheReducers: readonly JsonValue[];
+    order: number;
+    identityStability: IdentityStability;
+}
+export interface ClientRouteInspection {
+    clientId: string;
+    clientName?: string;
+    bindingId?: string;
+    bindingIdentity: string;
+    publicName: string;
+    routeKey: RouteKey;
+    enabled: boolean;
+    built: boolean;
+    build: {
+        feed: boolean;
+        singleton: boolean;
+        many: boolean;
+        pagination?: JsonValue;
+        options: SerializableClientBuildOptions;
+    };
+    augments: readonly ClientAugmentInspection[];
+    socketConnections: readonly ClientSocketConnectionInspection[];
+    identityStability: IdentityStability;
+}
+export interface ClientResourceInspection {
+    identity: string;
+    id?: string;
+    name?: string;
+    identityStability: IdentityStability;
+    bindings: readonly ClientRouteInspection[];
+}
+export interface MiddlewareInspection {
+    identity: string;
+    id?: string;
+    name?: string;
+    order: number;
+    identityStability: IdentityStability;
+}
+export interface ServerRouteInspection {
+    routeKey: RouteKey;
+    registered: boolean;
+    enabled: boolean;
+    controllerId?: string;
+    controllerName?: string;
+    before: readonly MiddlewareInspection[];
+    middleware: {
+        sanitizerCount: number;
+        preCtxCount: number;
+        postCtxCount: number;
+        beforeCount: number;
+    };
+    validateOutput: boolean;
+    multipart: boolean;
+    identityStability: IdentityStability;
+}
+export interface ServerRuntimeInspection {
+    identity: string;
+    id?: string;
+    name?: string;
+    identityStability: IdentityStability;
+    controllers: Readonly<Record<RouteKey, ServerRouteInspection>>;
+    middleware: {
+        sanitizerCount: number;
+        preCtxCount: number;
+        postCtxCount: number;
+    };
+    validateOutput: boolean;
+}
+export interface SocketContractEventInspection {
+    identity: string;
+    name: string;
+    schema?: SerializableSchema;
+}
+export interface SocketContractInspection {
+    events: Readonly<Record<string, SocketContractEventInspection>>;
+}
+export interface SocketConfigurationInspection {
+    heartbeat?: JsonValue;
+    reconnection?: JsonValue;
+    system?: JsonValue;
+    handlers: readonly SocketHandlerInspection[];
+}
+export interface SocketHandlerInspection {
+    identity: string;
+    event: string;
+    name?: string;
+    order: number;
+    identityStability: IdentityStability;
+}
+export interface SocketBindingInspection {
+    identity: string;
+    routeKey?: RouteKey;
+    eventNames: readonly string[];
+    identityStability: IdentityStability;
+}
+export interface SocketLiveInspection {
+    connected: boolean;
+    socketId?: string;
+    namespace?: string;
+    roomsCount?: number;
+    totalHandlers?: number;
+    rooms?: readonly {
+        room: string;
+        count: number;
+    }[];
+    handlers?: readonly {
+        event: string;
+        handlers: number;
+    }[];
+    routeSubscriptions?: readonly {
+        routeKey: RouteKey;
+        rooms: readonly {
+            room: string;
+            count: number;
+        }[];
+        handlers: readonly {
+            event: string;
+            handlers: number;
+        }[];
+    }[];
+}
+export interface SocketRuntimeInspection {
+    identity: string;
+    id?: string;
+    name?: string;
+    identityStability: IdentityStability;
+    contract: SocketContractInspection;
+    configuration: SocketConfigurationInspection;
+    bindings: readonly SocketBindingInspection[];
+    live?: SocketLiveInspection;
+}
+export interface RouteSocketInspection {
+    identity: string;
+    clientBindingIdentity: string;
+    events: readonly string[];
+    roomStrategy?: JsonValue;
+    cacheReducers: readonly JsonValue[];
+    identityStability: IdentityStability;
+}
+export interface RouteInspectionStatus {
+    client: 'unbound' | 'bound' | 'disabled';
+    server: 'unavailable' | 'missing' | 'enabled' | 'disabled';
+    socket: 'none' | 'configured';
+}
+export interface RouteInspection {
+    routeKey: RouteKey;
+    id?: string;
+    method: string;
+    path: string;
+    contract: ContractRouteInspection;
+    clients: readonly ClientRouteInspection[];
+    server?: ServerRouteInspection;
+    sockets: readonly RouteSocketInspection[];
+    status: RouteInspectionStatus;
+}
+export interface RRRoutesSnapshot {
+    schemaVersion: 1;
+    meta: RRRoutesSnapshotMeta;
+    capabilities: RRRoutesSnapshotCapabilities;
+    routes: Readonly<Record<RouteKey, RouteInspection>>;
+    clients: Readonly<Record<string, ClientResourceInspection>>;
+    servers: Readonly<Record<string, ServerRuntimeInspection>>;
+    sockets: Readonly<Record<string, SocketRuntimeInspection>>;
+    diagnostics: readonly InspectionDiagnostic[];
+}

package/dist/storage/filesystem.d.ts

@@ -0,0 +1,5 @@
+import type { InspectionStorage } from './types';
+export type FileSystemInspectionStorageOptions = {
+    directory: string;
+};
+export declare function createFileSystemInspectionStorage(options: FileSystemInspectionStorageOptions): InspectionStorage;

package/dist/storage/memory.d.ts

@@ -0,0 +1,2 @@
+import type { InspectionStorage } from './types';
+export declare function createMemoryInspectionStorage(): InspectionStorage;

package/dist/storage/sqlite.d.ts

@@ -0,0 +1,15 @@
+import type { InspectionStorage } from './types';
+export interface SQLiteStatementLike {
+    run(...parameters: unknown[]): unknown;
+    get(...parameters: unknown[]): unknown;
+    all(...parameters: unknown[]): unknown;
+}
+/** Compatible with node:sqlite DatabaseSync and better-sqlite3 databases. */
+export interface SQLiteDatabaseLike {
+    exec(sql: string): unknown;
+    prepare(sql: string): SQLiteStatementLike;
+}
+export type SQLiteInspectionStorageOptions = {
+    database: SQLiteDatabaseLike;
+};
+export declare function createSQLiteInspectionStorage(options: SQLiteInspectionStorageOptions): InspectionStorage;

package/dist/storage/types.d.ts

@@ -0,0 +1,27 @@
+import type { RRRoutesChangeSet } from '../diff/types';
+import type { RRRoutesChangeSetSummary, RRRoutesCheckpoint, RRRoutesCheckpointSummary } from '../checkpoint/types';
+export interface CheckpointStore {
+    get(id: string): Promise<RRRoutesCheckpoint | undefined>;
+    getActive(scope: string): Promise<RRRoutesCheckpoint | undefined>;
+    list(scope?: string): Promise<readonly RRRoutesCheckpointSummary[]>;
+    save(checkpoint: RRRoutesCheckpoint): Promise<void>;
+    setActive(scope: string, checkpointId: string): Promise<void>;
+    delete(id: string): Promise<void>;
+}
+export interface ChangeSetQuery {
+    scope?: string;
+    limit?: number;
+}
+export interface ChangeSetStore {
+    get(id: string): Promise<RRRoutesChangeSet | undefined>;
+    findByTransition(scope: string, fromHash: string, toHash: string): Promise<RRRoutesChangeSet | undefined>;
+    list(query?: ChangeSetQuery): Promise<readonly RRRoutesChangeSetSummary[]>;
+    save(changeSet: RRRoutesChangeSet): Promise<void>;
+    delete?(id: string): Promise<void>;
+}
+export interface InspectionStorage {
+    checkpoints: CheckpointStore;
+    changes: ChangeSetStore;
+    /** Optional adapter-level transaction used to make multi-store advancement atomic. */
+    transaction?<T>(operation: () => Promise<T>): Promise<T>;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@emeryld/rrroutes-export",
   "description": "Finalized leaves export helpers and CLI for RRRoutes",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "private": false,
   "type": "module",
   "main": "dist/index.cjs",
@@ -12,25 +12,84 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
       "require": "./dist/index.cjs"
+    },
+    "./inspection": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./snapshot": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./diff": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./checkpoint": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./storage/memory": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./storage/filesystem": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./storage/sqlite": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./http": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./express": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
     }
   },
   "bin": {
     "rrroutes-export-finalized-leaves": "./bin/rrroutes-export-finalized-leaves.mjs",
-    "rrroutes-export-changelog": "./bin/rrroutes-export-changelog.mjs"
+    "rrroutes-export-changelog": "./bin/rrroutes-export-changelog.mjs",
+    "rrroutes-export-snapshot": "./bin/rrroutes-export-snapshot.mjs",
+    "rrroutes-export-changes": "./bin/rrroutes-export-changes.mjs",
+    "rrroutes-checkpoint": "./bin/rrroutes-checkpoint.mjs",
+    "rrroutes-inspector-serve": "./bin/rrroutes-inspector-serve.mjs"
   },
   "files": [
     "dist",
     "tools/finalized-leaves-viewer.html",
     "bin/rrroutes-export-finalized-leaves.mjs",
-    "bin/rrroutes-export-changelog.mjs"
+    "bin/rrroutes-export-changelog.mjs",
+    "bin/rrroutes-export-snapshot.mjs",
+    "bin/rrroutes-export-changes.mjs",
+    "bin/rrroutes-checkpoint.mjs",
+    "bin/rrroutes-inspector-serve.mjs"
   ],
   "dependencies": {
-    "@emeryld/rrroutes-contract": "^2.9.4",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "@emeryld/rrroutes-contract": "^2.10.4"
   },
   "peerDependencies": {
+    "express": "^5.1.0",
     "zod": "^4.0.0"
   },
+  "peerDependenciesMeta": {
+    "express": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@jest/globals": "^30.4.1",
     "zod": "4.3.6"
@@ -40,8 +99,8 @@
     "url": "https://github.com/EmeryK-1/RRRoutes.git"
   },
   "scripts": {
-    "clean": "rimraf dist && rimraf node_modules",
-    "build": "pnpm run clean && pnpm install && pnpm run build:js && pnpm run build:types",
+    "clean": "rimraf dist",
+    "build": "pnpm run clean && pnpm run build:js && pnpm run build:types",
     "build:js": "tsup --config tsup.config.ts",
     "build:types": "tsc -p tsconfig.build.json",
     "typecheck": "tsc -p tsconfig.json --noEmit",