@tailorkit/app 0.1.0-beta.2 → 0.1.0-beta.21

package/dist/protocol.d.ts

@@ -0,0 +1,74 @@
+import type { ContractRouterClient } from "@orpc/contract";
+import { z } from "zod";
+export declare const invocationSchema: z.ZodObject<{
+    name: z.ZodString;
+    args: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strict>;
+export type Invocation = z.infer<typeof invocationSchema>;
+export type MutationInvocation = Invocation & {
+    requestId: string;
+};
+/** Public wire contract; implementations and clients both depend on this definition. */
+export declare const appContract: {
+    queries: import("@orpc/contract").ProcedureContractBuilderWithInputOutput<z.ZodObject<{
+        name: z.ZodString;
+        args: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>, import("@orpc/contract").Schema<unknown, unknown>, {
+        BAD_REQUEST: {};
+        UNAUTHORIZED: {};
+        FORBIDDEN: {};
+        NOT_FOUND: {};
+        CONFLICT: {};
+        INCOMPATIBLE_VERSION: {};
+        UNAVAILABLE: {};
+        INTERNAL_SERVER_ERROR: {};
+    }>;
+    mutations: import("@orpc/contract").ProcedureContractBuilderWithInputOutput<z.ZodObject<{
+        name: z.ZodString;
+        args: z.ZodOptional<z.ZodUnknown>;
+        requestId: z.ZodUUID;
+    }, z.core.$strict>, import("@orpc/contract").Schema<unknown, unknown>, {
+        BAD_REQUEST: {};
+        UNAUTHORIZED: {};
+        FORBIDDEN: {};
+        NOT_FOUND: {};
+        CONFLICT: {};
+        INCOMPATIBLE_VERSION: {};
+        UNAVAILABLE: {};
+        INTERNAL_SERVER_ERROR: {};
+    }>;
+    actions: import("@orpc/contract").ProcedureContractBuilderWithInputOutput<z.ZodObject<{
+        name: z.ZodString;
+        args: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>, import("@orpc/contract").Schema<unknown, unknown>, {
+        BAD_REQUEST: {};
+        UNAUTHORIZED: {};
+        FORBIDDEN: {};
+        NOT_FOUND: {};
+        CONFLICT: {};
+        INCOMPATIBLE_VERSION: {};
+        UNAVAILABLE: {};
+        INTERNAL_SERVER_ERROR: {};
+    }>;
+    subscribe: import("@orpc/contract").ProcedureContractBuilderWithInputOutput<z.ZodObject<{
+        name: z.ZodString;
+        args: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>, import("@orpc/contract").Schema<AsyncIterableIterator<unknown>, AsyncIterableIterator<unknown>>, {
+        BAD_REQUEST: {};
+        UNAUTHORIZED: {};
+        FORBIDDEN: {};
+        NOT_FOUND: {};
+        CONFLICT: {};
+        INCOMPATIBLE_VERSION: {};
+        UNAVAILABLE: {};
+        INTERNAL_SERVER_ERROR: {};
+    }>;
+};
+export type PlatformClient = ContractRouterClient<typeof appContract>;
+export type SubscriptionClient = Pick<PlatformClient, "subscribe">;
+/** Drizzle-generated SQL exported by application bundles. */
+export interface AppMigration {
+    id: string;
+    hash: string;
+    statements: string[];
+}

package/dist/protocol.js

@@ -0,0 +1,28 @@
+// src/protocol.ts
+import { oc, type } from "@orpc/contract";
+import { z } from "zod";
+var invocationSchema = z.strictObject({
+  name: z.string().max(512).regex(/^(?:[a-zA-Z][a-zA-Z0-9_]{0,63}|_tailorkit)(?:\.[a-zA-Z][a-zA-Z0-9_]{0,63})*$/u),
+  args: z.unknown().optional()
+});
+var procedure = oc.errors({
+  BAD_REQUEST: {},
+  UNAUTHORIZED: {},
+  FORBIDDEN: {},
+  NOT_FOUND: {},
+  CONFLICT: {},
+  INCOMPATIBLE_VERSION: {},
+  UNAVAILABLE: {},
+  INTERNAL_SERVER_ERROR: {}
+});
+var appContract = {
+  queries: procedure.input(invocationSchema).output(type()),
+  mutations: procedure.input(invocationSchema.extend({ requestId: z.uuid() })).output(type()),
+  actions: procedure.input(invocationSchema).output(type()),
+  // A pass-through type schema preserves the private hibernation iterator instance.
+  subscribe: procedure.input(invocationSchema).output(type())
+};
+export {
+  appContract,
+  invocationSchema
+};

package/dist/server/builder.d.ts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import type { MutationDatabase, QueryDatabase } from "../database/types";
+import type { ActionContext, FunctionKind, Functions, Identity } from "./functions";
+type HandlerContext<K extends FunctionKind, A extends z.ZodType, F extends Functions> = {
+    input: z.output<A>;
+} & (K extends "action" ? ActionContext<F> : {
+    db: K extends "query" ? QueryDatabase : MutationDatabase;
+    identity: Identity;
+});
+type OutputInput<R> = R extends z.ZodType ? z.input<R> : unknown;
+type HandlerOutput<K, O> = K extends "action" ? O | Promise<O> : O & ([O] extends [never] ? unknown : O extends PromiseLike<unknown> ? never : unknown);
+type BuiltFunction<K extends FunctionKind, A extends z.ZodType, R, O, F extends Functions> = {
+    readonly kind: K;
+    readonly args: A;
+    readonly handler: (context: Omit<HandlerContext<K, A, F>, "input"> & {
+        args: z.output<A>;
+    }) => HandlerOutput<K, O>;
+} & (R extends z.ZodType ? {
+    readonly result: R;
+} : unknown) & (K extends "action" ? {
+    readonly functions: F;
+} : unknown);
+/** Immutable builders preserve the validated input and wire output types at every step. */
+declare class FunctionBuilder<K extends FunctionKind, A extends z.ZodType, R extends z.ZodType | undefined = undefined, F extends Functions = Record<never, never>> {
+    private readonly kind;
+    private readonly args;
+    private readonly result;
+    private readonly calls;
+    constructor(kind: K, args: A, result: R, calls: F);
+    input<S extends z.ZodType>(schema: S): FunctionBuilder<K, S, R, F>;
+    output<S extends z.ZodType>(schema: S): FunctionBuilder<K, A, S, F>;
+    functions<const G extends Functions>(this: FunctionBuilder<"action", A, R, F>, functions: G): FunctionBuilder<"action", A, R, G>;
+    handler<O extends OutputInput<R>>(handler: (context: HandlerContext<K, A, F>) => HandlerOutput<K, O>): BuiltFunction<K, A, R, O, F>;
+}
+export declare const tk: Readonly<{
+    query: FunctionBuilder<"query", z.ZodUndefined, undefined, {}>;
+    mutation: FunctionBuilder<"mutation", z.ZodUndefined, undefined, {}>;
+    action: FunctionBuilder<"action", z.ZodUndefined, undefined, {}>;
+}>;
+export {};

package/dist/server/bundle.d.ts

@@ -0,0 +1,17 @@
+import type { AppDefinition } from "./functions";
+import type { AppMigration } from "../protocol";
+/** Interface between an uploaded application module and the server runtime. */
+export interface RuntimeManifest {
+    apiVersion: number;
+    requires: readonly string[];
+}
+export interface ApplicationModule {
+    default: AppDefinition;
+    migrations: readonly AppMigration[];
+    runtimeManifest: RuntimeManifest;
+}
+/** Emitted by this SDK's builder; breaking interface changes increment apiVersion. */
+export declare const runtimeManifest: {
+    readonly apiVersion: 1;
+    readonly requires: readonly ["database", "actions"];
+};

package/dist/server/functions.d.ts

@@ -0,0 +1,89 @@
+import type { z } from "zod";
+import type { QueryDatabase, MutationDatabase } from "../database/types";
+export interface Identity {
+    readonly userId: string;
+    readonly projectId: string;
+    readonly appId: string;
+    readonly installationId: string;
+    readonly deploymentId: string;
+    readonly expiresAt: number;
+}
+export type FunctionKind = "query" | "mutation" | "action";
+export type FunctionResult<D> = D extends {
+    result: infer R extends z.ZodType;
+} ? z.output<R> : D extends {
+    handler: (context: never) => infer O;
+} ? Awaited<O> : never;
+export type FunctionCalls<F, K extends "query" | "mutation"> = {
+    readonly [N in keyof F as F[N] extends {
+        kind: FunctionKind;
+    } ? (F[N] extends {
+        kind: K;
+    } ? N : never) : N]: F[N] extends {
+        args: infer A extends z.ZodType;
+        handler: (context: never) => unknown;
+    } ? K extends "mutation" ? (...args: undefined extends z.input<A> ? [args?: z.input<A>, options?: {
+        requestId?: string;
+    }] : [args: z.input<A>, options?: {
+        requestId?: string;
+    }]) => Promise<FunctionResult<F[N]>> : (...args: undefined extends z.input<A> ? [args?: z.input<A>] : [args: z.input<A>]) => Promise<FunctionResult<F[N]>> : F[N] extends Functions ? FunctionCalls<F[N], K> : never;
+};
+export interface ActionContext<F extends Functions = Record<never, never>> {
+    readonly identity: Identity;
+    readonly signal: AbortSignal;
+    readonly queries: FunctionCalls<F, "query">;
+    readonly mutations: FunctionCalls<F, "mutation">;
+}
+export interface FunctionDefinition<K extends FunctionKind, A extends z.ZodType, O, F extends Functions = Record<never, never>> {
+    readonly kind: K;
+    readonly args: A;
+    readonly result?: z.ZodType<O>;
+    readonly handler: (context: {
+        args: z.output<A>;
+    } & (K extends "action" ? ActionContext<F> : {
+        db: K extends "query" ? QueryDatabase : MutationDatabase;
+        identity: Identity;
+    })) => K extends "action" ? O | Promise<O> : O;
+}
+export declare function query<A extends z.ZodType, O>(definition: Omit<FunctionDefinition<"query", A, O>, "kind"> & {
+    handler: FunctionDefinition<"query", A, O>["handler"] & ([O] extends [never] ? unknown : O extends PromiseLike<unknown> ? never : unknown);
+}): Readonly<{
+    args: A;
+    result?: z.ZodType<O, unknown, z.core.$ZodTypeInternals<O, unknown>> | undefined;
+    handler: FunctionDefinition<"query", A, O>["handler"] & ([O] extends [never] ? unknown : O extends PromiseLike<unknown> ? never : unknown);
+    kind: "query";
+}>;
+export declare function mutation<A extends z.ZodType, O>(definition: Omit<FunctionDefinition<"mutation", A, O>, "kind"> & {
+    handler: FunctionDefinition<"mutation", A, O>["handler"] & ([O] extends [never] ? unknown : O extends PromiseLike<unknown> ? never : unknown);
+}): Readonly<{
+    args: A;
+    result?: z.ZodType<O, unknown, z.core.$ZodTypeInternals<O, unknown>> | undefined;
+    handler: FunctionDefinition<"mutation", A, O>["handler"] & ([O] extends [never] ? unknown : O extends PromiseLike<unknown> ? never : unknown);
+    kind: "mutation";
+}>;
+export declare function action<A extends z.ZodType, O, const F extends Functions = Record<never, never>>(definition: Omit<FunctionDefinition<"action", A, O, F>, "kind"> & {
+    functions?: F;
+}): Readonly<{
+    args: A;
+    result?: z.ZodType<O, unknown, z.core.$ZodTypeInternals<O, unknown>> | undefined;
+    handler: (context: {
+        args: z.infer<A>;
+    } & ActionContext<F>) => O | Promise<O>;
+    functions?: F;
+    kind: "action";
+}>;
+export type RegisteredFunction = {
+    kind: FunctionKind;
+    args: z.ZodType;
+    result?: z.ZodType;
+    handler: (context: never) => unknown;
+    functions?: Functions;
+};
+export interface Functions {
+    readonly [name: string]: RegisteredFunction | Functions;
+}
+export declare function isFunction(value: RegisteredFunction | Functions): value is RegisteredFunction;
+export declare function defineServer<const F extends Functions>(functions: F): Readonly<{
+    functions: F;
+}>;
+export type AppDefinition = ReturnType<typeof defineServer>;

package/dist/server/instances.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import type { AppDefinition, Identity } from "./functions";
+interface InstanceResolver {
+    slot: string;
+    path: string;
+    dataSchema: z.ZodType;
+    resolve: (context: {
+        context: Record<string, unknown>;
+        identity: Identity;
+        signal: AbortSignal;
+        queries: unknown;
+    }) => unknown;
+}
+/** Build-generated actions run through the existing authenticated action runtime. */
+export declare function withInstanceResolvers(app: AppDefinition, resolvers: readonly InstanceResolver[]): AppDefinition;
+export {};

package/dist/server.d.ts

@@ -0,0 +1,9 @@
+export { defineServer, query, mutation, action } from "./server/functions";
+export { tk } from "./server/builder";
+export { withInstanceResolvers } from "./server/instances";
+export type { QueryDatabase, MutationDatabase } from "./database/types";
+export type { Identity, FunctionDefinition, AppDefinition, ActionContext, FunctionKind, } from "./server/functions";
+export { table, text, integer, real, boolean, eq, ne, gt, gte, lt, lte, and, or, asc, desc, count, isNull, isNotNull, inArray, } from "./database/schema";
+export { AppError } from "./errors";
+export type { ErrorCode } from "./errors";
+export type { ApplicationModule, RuntimeManifest } from "./server/bundle";

package/dist/server.js

@@ -0,0 +1,58 @@
+import {
+  action,
+  and,
+  asc,
+  boolean,
+  count,
+  defineServer,
+  desc,
+  eq,
+  gt,
+  gte,
+  inArray,
+  integer,
+  isNotNull,
+  isNull,
+  lt,
+  lte,
+  mutation,
+  ne,
+  or,
+  query,
+  real,
+  table,
+  text,
+  tk,
+  withInstanceResolvers
+} from "./chunk-7NOEYJOB.js";
+import {
+  AppError
+} from "./chunk-IJBQ77AH.js";
+export {
+  AppError,
+  action,
+  and,
+  asc,
+  boolean,
+  count,
+  defineServer,
+  desc,
+  eq,
+  gt,
+  gte,
+  inArray,
+  integer,
+  isNotNull,
+  isNull,
+  lt,
+  lte,
+  mutation,
+  ne,
+  or,
+  query,
+  real,
+  table,
+  text,
+  tk,
+  withInstanceResolvers
+};

package/dist/views.d.ts

@@ -0,0 +1,139 @@
+import { h } from "preact";
+import type { ComponentChild, ComponentChildren, ComponentType, VNode } from "preact";
+import type { z } from "zod";
+import type { FunctionCalls, Identity } from "./server/functions";
+export interface TailorKitViews {
+}
+export interface TailorKitSlots {
+}
+export interface TailorKitServerFunctions {
+}
+export interface ViewInstance<TData = unknown> {
+    key: string;
+    metadata: Record<string, unknown>;
+    data: TData;
+}
+export interface InstanceResolverContext<TPath extends AppViewPath> {
+    context: ViewContext<TPath>;
+    identity: Identity;
+    signal: AbortSignal;
+    queries: FunctionCalls<TailorKitServerFunctions, "query">;
+}
+export interface ViewInstances<TPath extends AppViewPath, TSchema extends z.ZodType> {
+    dataSchema: TSchema;
+    /** Runs on the app server. Only registered queries are available. */
+    resolve: (context: InstanceResolverContext<TPath>) => ViewInstance<z.input<TSchema>>[] | Promise<ViewInstance<z.input<TSchema>>[]>;
+}
+export type SlotName = keyof TailorKitSlots & string;
+export type ViewPath = Extract<keyof TailorKitViews & string, `/${string}`>;
+export type AppViewPath = ViewPath;
+export type ViewProps<TPath extends ViewPath> = TailorKitViews[TPath] extends object ? TailorKitViews[TPath] : Record<string, never>;
+export type ViewPropsForPath<TPath extends AppViewPath> = TPath extends ViewPath ? ViewProps<TPath> : never;
+export type ViewContext<TPath extends AppViewPath> = ViewPropsForPath<TPath> extends {
+    context: infer TContext;
+} ? TContext : Record<string, never>;
+export type View<TProps extends object = Record<string, never>> = (props: TProps) => ComponentChild;
+export type ViewRuntimeProps<TPath extends AppViewPath, TData = unknown> = {
+    context: ViewContext<TPath>;
+    view: TPath;
+    status: "ready";
+    instance?: ViewInstance<TData>;
+} | {
+    context?: never;
+    view: TPath;
+    status: "loading";
+    instance?: never;
+} | {
+    context?: never;
+    view: TPath;
+    status: "error";
+    instance?: never;
+};
+export interface ViewDefinition<TPath extends AppViewPath = AppViewPath, TData = unknown, TSlot extends SlotName = SlotName> {
+    component: View<ViewRuntimeProps<TPath>>;
+    path: TPath;
+    slot: TSlot;
+    useContext: () => ViewContext<TPath>;
+    /** The selected instance, with data inferred from instances.dataSchema. */
+    useInstance: () => ViewInstance<TData>;
+    /** Build-only lookup key connecting this view to its extracted server implementation. */
+    instances?: {
+        resolver: string;
+    };
+}
+type InvalidViewPath<TViews> = Exclude<keyof TViews & string, AppViewPath>;
+type RequireViewPaths<TViews> = InvalidViewPath<TViews> extends never ? unknown : {
+    readonly __tailorkit_error__: `View paths must be declared by the host. Invalid view: ${InvalidViewPath<TViews>}`;
+};
+type ViewKeyPathMismatch<TViews> = {
+    [TPath in keyof TViews & string]: TViews[TPath] extends false ? never : TViews[TPath] extends ViewDefinition<infer TViewPath> ? TViewPath extends TPath ? never : TPath : TPath;
+}[keyof TViews & string];
+type RequireMatchingViewKeys<TViews> = ViewKeyPathMismatch<TViews> extends never ? unknown : {
+    readonly __tailorkit_error__: `View key must match defineView path. Invalid view: ${ViewKeyPathMismatch<TViews>}`;
+};
+export type SlotView<TSlot extends SlotName> = TailorKitSlots[TSlot] extends {
+    views: infer TViews;
+} ? Extract<TViews, AppViewPath> : never;
+type SlotInstanceDefinition<TSlot extends SlotName> = TailorKitSlots[TSlot] extends {
+    multiple: true;
+} ? {
+    instances: {
+        resolver: string;
+    };
+} : {
+    instances?: never;
+};
+type SlotDefinitions = {
+    [V in SlotName]?: Partial<{
+        [P in SlotView<V>]: (ViewDefinition<P, unknown, V> & SlotInstanceDefinition<V>) | false;
+    }>;
+};
+type RequireSlotViews<V, S> = V extends SlotName ? Exclude<keyof S, SlotView<V>> extends never ? unknown : {
+    readonly __tailorkit_error__: "View is not supported by this slot";
+} : never;
+export interface TailorKitClient<TSlots extends SlotDefinitions = SlotDefinitions> {
+    slots: TSlots;
+    /** Wrap the app root with providers shared by every view. */
+    component?: ComponentType<{
+        children?: ComponentChildren;
+    }>;
+}
+export interface TailorKitClientMeta {
+    preactVersion: string;
+}
+export interface TailorKitClientRuntime {
+    h: typeof h;
+    render: (vnode: VNode | null, parent: Element | Document | ShadowRoot | DocumentFragment) => void;
+}
+export type TailorKitClientWithMeta<TViews extends SlotDefinitions = SlotDefinitions> = TailorKitClient<TViews> & {
+    $meta: TailorKitClientMeta;
+    $runtime: TailorKitClientRuntime;
+};
+type ViewOptions<TPath extends AppViewPath, TSlot extends SlotName, TSchema extends z.ZodType> = {
+    [S in TSlot]: {
+        slot: S;
+        view: TPath;
+        component: View<Record<string, never>>;
+    } & (TPath extends SlotView<S> ? unknown : {
+        readonly __tailorkit_error__: "View is not supported by this slot";
+    }) & (TailorKitSlots[S] extends {
+        multiple: true;
+    } ? {
+        instances: ViewInstances<TPath, TSchema>;
+    } : {
+        instances?: never;
+    });
+}[TSlot];
+export declare const defineView: <const TPath extends AppViewPath, const TSlot extends SlotName, TSchema extends z.ZodType>(options: ViewOptions<TPath, TSlot, TSchema>) => ViewDefinition<TPath, z.output<TSchema>, TSlot> & SlotInstanceDefinition<TSlot>;
+export declare const defineClient: <const TSlots extends SlotDefinitions>(client: TailorKitClient<TSlots> & {
+    slots: { [V in keyof TSlots]: TSlots[V] & RequireViewPaths<TSlots[V]> & RequireMatchingViewKeys<TSlots[V]> & RequireSlotViews<V, TSlots[V]>; };
+} & (Exclude<keyof TSlots, SlotName> extends never ? unknown : {
+    __tailorkit_error__: "Unknown slot";
+})) => TailorKitClientWithMeta<TSlots>;
+export declare const createRemoteComponent: <TProps extends object, TChildren extends boolean = false>(name: string, options?: {
+    callbacks?: Record<string, number>;
+    children?: TChildren;
+}) => View<TProps & {
+    children?: TChildren extends true ? ComponentChildren : never;
+}>;
+export {};

package/package.json

@@ -1,68 +1,75 @@
 {
   "name": "@tailorkit/app",
-  "version": "0.1.0-beta.2",
-  "license": "AGPL-3.0-only",
+  "version": "0.1.0-beta.21",
+  "license": "Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/AlfieJones/tailorkit.git",
+    "url": "git+https://github.com/tailorkit-labs/TailorKit.git",
     "directory": "packages/app"
   },
   "files": [
     "dist"
   ],
   "type": "module",
-  "imports": {
-    "#*": [
-      "./src/*",
-      "./src/*.ts",
-      "./src/*.tsx",
-      "./src/*/index.ts",
-      "./src/*/index.tsx"
-    ]
-  },
   "exports": {
     ".": {
-      "development": "./src/index.ts",
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
     "./config": {
-      "development": "./src/config/index.ts",
       "types": "./dist/config/index.d.ts",
       "import": "./dist/config.js"
     },
     "./config/loader": {
-      "development": "./src/config/loader.ts",
       "types": "./dist/config/loader.d.ts",
       "import": "./dist/config-loader.js"
     },
     "./builder": {
-      "development": "./src/builder/index.ts",
       "types": "./dist/builder/index.d.ts",
       "import": "./dist/builder.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js"
+    },
+    "./protocol": {
+      "types": "./dist/protocol.d.ts",
+      "import": "./dist/protocol.js"
     }
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@tailorkit/core": "0.1.0-beta.2",
-    "cosmiconfig": "^10.0.0",
-    "vite": "^8.2.2",
-    "zod": "^4.4.3"
+    "@orpc/client": "2.0.0-beta.40",
+    "@orpc/contract": "2.0.0-beta.40",
+    "@tanstack/preact-store": "0.13.4",
+    "@tanstack/store": "0.11.2",
+    "cosmiconfig": "^10.0.1",
+    "drizzle-orm": "1.0.0-rc.4-5d5b77c",
+    "vite": "npm:@voidzero-dev/vite-plus-core@1.0.0",
+    "zod": "^4.6.5"
   },
   "devDependencies": {
+    "@tailorkit/asset-delivery": "0.0.0",
     "@tailorkit/config": "0.0.0",
-    "@types/node": "26.2.0",
+    "@types/node": "26.6.4",
+    "happy-dom": "^20.14.5",
     "preact": "^10.29.8",
     "tsup": "^8.5.1",
-    "typescript": "^7.0.2"
+    "typescript": "^7.0.2",
+    "vite-plus": "1.0.0"
   },
   "peerDependencies": {
     "preact": "^10.0.0"
   },
   "scripts": {
     "build": "tsup --config tsup.config.ts && tsc -p tsconfig.build.json",
-    "check-types": "tsc --noEmit"
+    "check-types": "tsc --noEmit",
+    "test": "vp test run"
   }
 }