@tailorkit/app 0.1.0-beta.29 → 0.1.0-beta.32

package/dist/protocol.d.ts

@@ -1,8 +1,8 @@
 import type { ContractRouterClient } from "@orpc/contract";
 import { z } from "zod";
 export declare const invocationSchema: z.ZodObject<{
-    name: z.ZodString;
     args: z.ZodOptional<z.ZodUnknown>;
+    name: z.ZodString;
 }, z.core.$strict>;
 export type Invocation = z.infer<typeof invocationSchema>;
 export type MutationInvocation = Invocation & {
@@ -10,58 +10,58 @@ export type MutationInvocation = Invocation & {
 };
 /** 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;
+    actions: import("@orpc/contract").ProcedureContractBuilderWithInputOutput<z.ZodObject<{
         args: z.ZodOptional<z.ZodUnknown>;
+        name: z.ZodString;
     }, z.core.$strict>, import("@orpc/contract").Schema<unknown, unknown>, {
         BAD_REQUEST: {};
-        UNAUTHORIZED: {};
-        FORBIDDEN: {};
-        NOT_FOUND: {};
         CONFLICT: {};
+        FORBIDDEN: {};
         INCOMPATIBLE_VERSION: {};
-        UNAVAILABLE: {};
         INTERNAL_SERVER_ERROR: {};
+        NOT_FOUND: {};
+        UNAUTHORIZED: {};
+        UNAVAILABLE: {};
     }>;
     mutations: import("@orpc/contract").ProcedureContractBuilderWithInputOutput<z.ZodObject<{
-        name: z.ZodString;
         args: z.ZodOptional<z.ZodUnknown>;
+        name: z.ZodString;
         requestId: z.ZodUUID;
     }, z.core.$strict>, import("@orpc/contract").Schema<unknown, unknown>, {
         BAD_REQUEST: {};
-        UNAUTHORIZED: {};
-        FORBIDDEN: {};
-        NOT_FOUND: {};
         CONFLICT: {};
+        FORBIDDEN: {};
         INCOMPATIBLE_VERSION: {};
-        UNAVAILABLE: {};
         INTERNAL_SERVER_ERROR: {};
+        NOT_FOUND: {};
+        UNAUTHORIZED: {};
+        UNAVAILABLE: {};
     }>;
-    actions: import("@orpc/contract").ProcedureContractBuilderWithInputOutput<z.ZodObject<{
-        name: z.ZodString;
+    queries: import("@orpc/contract").ProcedureContractBuilderWithInputOutput<z.ZodObject<{
         args: z.ZodOptional<z.ZodUnknown>;
+        name: z.ZodString;
     }, z.core.$strict>, import("@orpc/contract").Schema<unknown, unknown>, {
         BAD_REQUEST: {};
-        UNAUTHORIZED: {};
-        FORBIDDEN: {};
-        NOT_FOUND: {};
         CONFLICT: {};
+        FORBIDDEN: {};
         INCOMPATIBLE_VERSION: {};
-        UNAVAILABLE: {};
         INTERNAL_SERVER_ERROR: {};
+        NOT_FOUND: {};
+        UNAUTHORIZED: {};
+        UNAVAILABLE: {};
     }>;
     subscribe: import("@orpc/contract").ProcedureContractBuilderWithInputOutput<z.ZodObject<{
-        name: z.ZodString;
         args: z.ZodOptional<z.ZodUnknown>;
+        name: z.ZodString;
     }, z.core.$strict>, import("@orpc/contract").Schema<AsyncIterableIterator<unknown>, AsyncIterableIterator<unknown>>, {
         BAD_REQUEST: {};
-        UNAUTHORIZED: {};
-        FORBIDDEN: {};
-        NOT_FOUND: {};
         CONFLICT: {};
+        FORBIDDEN: {};
         INCOMPATIBLE_VERSION: {};
-        UNAVAILABLE: {};
         INTERNAL_SERVER_ERROR: {};
+        NOT_FOUND: {};
+        UNAUTHORIZED: {};
+        UNAVAILABLE: {};
     }>;
 };
 export type PlatformClient = ContractRouterClient<typeof appContract>;

package/dist/protocol.js

@@ -2,23 +2,25 @@
 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()
+  args: z.unknown().optional(),
+  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
+  )
 });
 var procedure = oc.errors({
   BAD_REQUEST: {},
-  UNAUTHORIZED: {},
-  FORBIDDEN: {},
-  NOT_FOUND: {},
   CONFLICT: {},
+  FORBIDDEN: {},
   INCOMPATIBLE_VERSION: {},
-  UNAVAILABLE: {},
-  INTERNAL_SERVER_ERROR: {}
+  INTERNAL_SERVER_ERROR: {},
+  NOT_FOUND: {},
+  UNAUTHORIZED: {},
+  UNAVAILABLE: {}
 });
 var appContract = {
-  queries: procedure.input(invocationSchema).output(type()),
-  mutations: procedure.input(invocationSchema.extend({ requestId: z.uuid() })).output(type()),
   actions: procedure.input(invocationSchema).output(type()),
+  mutations: procedure.input(invocationSchema.extend({ requestId: z.uuid() })).output(type()),
+  queries: procedure.input(invocationSchema).output(type()),
   // A pass-through type schema preserves the private hibernation iterator instance.
   subscribe: procedure.input(invocationSchema).output(type())
 };

package/dist/routing.d.ts

@@ -7,9 +7,9 @@ export interface RouteDefinition {
     readonly shellComponent: ComponentType<ShellProps>;
 }
 /** Define the shell in an app or slot root.tsx. */
-export declare function defineRoute(options: RouteDefinition): RouteDefinition;
+export declare const defineRoute: (options: RouteDefinition) => RouteDefinition;
 /** Render the next layout or selected view inside a root shell or layout. */
-export declare function Route(): string | number | bigint | boolean | object | import("preact").ComponentChild[] | import("preact").VNode<any> | null;
+export declare const Route: () => string | number | bigint | boolean | object | import("preact").ComponentChild[] | import("preact").VNode<any> | null;
 export interface RouteModule {
     filename: string;
     definition: unknown;
@@ -24,11 +24,11 @@ export interface FileLayoutModule extends RouteModule {
 /** The app builder generates this registration; apps only export their files.
  * @internal
  */
-export declare function createFileClient(options: {
+export declare const createFileClient: (options: {
     root?: RouteModule;
     roots: (RouteModule & {
         slot: string;
     })[];
     layouts: FileLayoutModule[];
     views: FileViewModule[];
-}): TailorKitClientWithMeta;
+}) => TailorKitClientWithMeta;

package/dist/server/builder.d.ts

@@ -1,7 +1,7 @@
-import { z } from "zod";
 import type { AnyRelations, EmptyRelations } from "drizzle-orm/relations";
-import type { DatabaseDefinition } from "../database/definition";
-import type { MutationDatabase, QueryDatabase } from "../database/types";
+import { z } from "zod";
+import type { DatabaseDefinition } from "#database/definition";
+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, D extends AnyRelations> = {
     input: z.output<A>;
@@ -37,9 +37,9 @@ declare class FunctionBuilder<K extends FunctionKind, A extends z.ZodType, R ext
     database<const E extends AnyRelations>(this: FunctionBuilder<K, A, R, F, D> & (K extends "action" ? never : unknown), database: DatabaseDefinition<E>): FunctionBuilder<K, A, R, F, E>;
     handler<O extends OutputInput<R>>(handler: (context: HandlerContext<K, A, F, D>) => HandlerOutput<K, O>): BuiltFunction<K, A, R, O, F, D>;
 }
-export declare const tk: Readonly<{
-    query: FunctionBuilder<"query", z.ZodUndefined, undefined, {}, EmptyRelations>;
-    mutation: FunctionBuilder<"mutation", z.ZodUndefined, undefined, {}, EmptyRelations>;
+export declare const fn: Readonly<{
     action: FunctionBuilder<"action", z.ZodUndefined, undefined, {}, EmptyRelations>;
+    mutation: FunctionBuilder<"mutation", z.ZodUndefined, undefined, {}, EmptyRelations>;
+    query: FunctionBuilder<"query", z.ZodUndefined, undefined, {}, EmptyRelations>;
 }>;
 export {};

package/dist/server/bundle.d.ts

@@ -1,5 +1,5 @@
+import type { AppMigration } from "#protocol";
 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;
@@ -10,8 +10,3 @@ export interface ApplicationModule {
     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", "database-relations", "tools"];
-};

package/dist/server/functions.d.ts

@@ -1,13 +1,13 @@
-import type { TailorKitServerTools } from "../client/tools";
-import type { z } from "zod";
 import type { AnyRelations, EmptyRelations } from "drizzle-orm/relations";
-import type { DatabaseDefinition } from "../database/definition";
-import type { QueryDatabase, MutationDatabase } from "../database/types";
+import type { z } from "zod";
+import type { TailorKitServerTools } from "#client/tools";
+import type { DatabaseDefinition } from "#database/definition";
+import type { QueryDatabase, MutationDatabase } from "#database/types";
 export interface Identity {
     readonly subjectId?: string;
     readonly scope: {
         name: string;
-        value: Record<string, unknown>;
+        value: Record<string, z.output<ReturnType<typeof z.json>>>;
     };
     readonly toolUrl: string;
     readonly projectId: string;
@@ -25,11 +25,11 @@ export type FunctionResult<D> = D extends {
 export type FunctionCalls<F, K extends "query" | "mutation"> = {
     readonly [N in keyof F as F[N] extends {
         kind: FunctionKind;
-    } ? (F[N] extends {
+    } ? F[N] extends {
         kind: K;
-    } ? N : never) : N]: F[N] extends {
+    } ? N : never : N]: F[N] extends {
         args: infer A extends z.ZodType;
-        handler: (context: never) => unknown;
+        handler: (context: never) => infer _Output;
     } ? K extends "mutation" ? (...args: undefined extends z.input<A> ? [args?: z.input<A>, options?: {
         requestId?: string;
     }] : [args: z.input<A>, options?: {
@@ -57,27 +57,27 @@ export interface FunctionDefinition<K extends FunctionKind, A extends z.ZodType,
         identity: Identity;
     })) => K extends "action" ? O | Promise<O> : O;
 }
-export declare function query<A extends z.ZodType, O, const D extends AnyRelations = EmptyRelations>(definition: Omit<FunctionDefinition<"query", A, O, Record<never, never>, D>, "kind"> & {
+export declare const query: <A extends z.ZodType, O, const D extends AnyRelations = EmptyRelations>(definition: Omit<FunctionDefinition<"query", A, O, Record<never, never>, D>, "kind"> & {
     handler: FunctionDefinition<"query", A, O, Record<never, never>, D>["handler"] & ([O] extends [never] ? unknown : O extends PromiseLike<unknown> ? never : unknown);
-}): Readonly<{
+}) => Readonly<{
     args: A;
     database?: DatabaseDefinition<D> | undefined;
     result?: z.ZodType<O, unknown, z.core.$ZodTypeInternals<O, unknown>> | undefined;
     handler: FunctionDefinition<"query", A, O, Record<never, never>, D>["handler"] & ([O] extends [never] ? unknown : O extends PromiseLike<unknown> ? never : unknown);
     kind: "query";
 }>;
-export declare function mutation<A extends z.ZodType, O, const D extends AnyRelations = EmptyRelations>(definition: Omit<FunctionDefinition<"mutation", A, O, Record<never, never>, D>, "kind"> & {
+export declare const mutation: <A extends z.ZodType, O, const D extends AnyRelations = EmptyRelations>(definition: Omit<FunctionDefinition<"mutation", A, O, Record<never, never>, D>, "kind"> & {
     handler: FunctionDefinition<"mutation", A, O, Record<never, never>, D>["handler"] & ([O] extends [never] ? unknown : O extends PromiseLike<unknown> ? never : unknown);
-}): Readonly<{
+}) => Readonly<{
     args: A;
     database?: DatabaseDefinition<D> | undefined;
     result?: z.ZodType<O, unknown, z.core.$ZodTypeInternals<O, unknown>> | undefined;
     handler: FunctionDefinition<"mutation", A, O, Record<never, never>, D>["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"> & {
+export declare const action: <A extends z.ZodType, O, const F extends Functions = Record<never, never>>(definition: Omit<FunctionDefinition<"action", A, O, F>, "kind"> & {
     functions?: F;
-}): Readonly<{
+}) => Readonly<{
     args: A;
     database?: undefined;
     result?: z.ZodType<O, unknown, z.core.$ZodTypeInternals<O, unknown>> | undefined;
@@ -87,19 +87,19 @@ export declare function action<A extends z.ZodType, O, const F extends Functions
     functions?: F;
     kind: "action";
 }>;
-export type RegisteredFunction = {
+export interface RegisteredFunction<TOutput = unknown> {
     kind: FunctionKind;
     args: z.ZodType;
     result?: z.ZodType;
-    handler: (context: never) => unknown;
+    handler: (context: never) => TOutput;
     functions?: Functions;
     database?: DatabaseDefinition;
-};
+}
 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<{
+export declare const isFunction: (value: RegisteredFunction | Functions) => value is RegisteredFunction;
+export declare const defineServer: <const F extends Functions>(functions: F) => Readonly<{
     functions: F;
 }>;
 export type AppDefinition = ReturnType<typeof defineServer>;

package/dist/server/instances.d.ts

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

package/dist/server.d.ts

@@ -1,7 +1,7 @@
 export { defineServer, query, mutation, action } from "./server/functions";
 export { defineDatabase } from "./database/definition";
 export type { DatabaseDefinition } from "./database/definition";
-export { tk } from "./server/builder";
+export { fn } 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";

package/dist/server.js

@@ -8,6 +8,7 @@ import {
   defineServer,
   desc,
   eq,
+  fn,
   gt,
   gte,
   inArray,
@@ -23,12 +24,11 @@ import {
   real,
   table,
   text,
-  tk,
   withInstanceResolvers
-} from "./chunk-ANTVMHDZ.js";
+} from "./chunk-YX3JURMG.js";
 import {
   AppError
-} from "./chunk-IJBQ77AH.js";
+} from "./chunk-7ZQPXG7O.js";
 export {
   AppError,
   action,
@@ -40,6 +40,7 @@ export {
   defineServer,
   desc,
   eq,
+  fn,
   gt,
   gte,
   inArray,
@@ -55,6 +56,5 @@ export {
   real,
   table,
   text,
-  tk,
   withInstanceResolvers
 };

package/dist/views.d.ts

@@ -8,9 +8,10 @@ export interface TailorKitSlots {
 }
 export interface TailorKitServerFunctions {
 }
+export type ViewDataFields = Record<string, unknown>;
 export interface ViewInstance<TData = unknown> {
     key: string;
-    metadata: Record<string, unknown>;
+    metadata: ViewDataFields;
     data: TData;
 }
 export interface InstanceResolverContext<TPath extends AppViewPath> {
@@ -96,7 +97,7 @@ type ViewOptions<TPath extends AppViewPath, TSlot extends SlotName, TSchema exte
     [S in TSlot]: {
         slot: S;
         view: TPath;
-        component: View<Record<string, never>>;
+        component: View;
     } & (TPath extends SlotView<S> ? unknown : {
         readonly __tailorkit_error__: "View is not supported by this slot";
     }) & (TailorKitSlots[S] extends {
@@ -112,7 +113,7 @@ type ViewOptions<TPath extends AppViewPath, TSlot extends SlotName, TSchema exte
 export declare function defineView<const TPath extends AppViewPath = AppViewPath, TSchema extends z.ZodType = z.ZodType>(options: {
     slot?: never;
     view?: TPath;
-    component: View<Record<string, never>>;
+    component: View;
     instances?: ViewInstances<TPath, TSchema>;
 }): ViewDefinition<TPath, z.output<TSchema>>;
 export declare function 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>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tailorkit/app",
-  "version": "0.1.0-beta.29",
+  "version": "0.1.0-beta.32",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -11,23 +11,35 @@
     "dist"
   ],
   "type": "module",
+  "imports": {
+    "#env": "./src/env.ts",
+    "#*": {
+      "development": [
+        "./src/*",
+        "./src/*.ts",
+        "./src/*.tsx",
+        "./src/*/index.ts",
+        "./src/*/index.tsx"
+      ],
+      "types": [
+        "./dist/*",
+        "./dist/*.d.ts",
+        "./dist/*/index.d.ts"
+      ],
+      "default": [
+        "./src/*",
+        "./src/*.ts",
+        "./src/*.tsx",
+        "./src/*/index.ts",
+        "./src/*/index.tsx"
+      ]
+    }
+  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
-    "./config": {
-      "types": "./dist/config/index.d.ts",
-      "import": "./dist/config.js"
-    },
-    "./config/loader": {
-      "types": "./dist/config/loader.d.ts",
-      "import": "./dist/config-loader.js"
-    },
-    "./builder": {
-      "types": "./dist/builder/index.d.ts",
-      "import": "./dist/builder.js"
-    },
     "./client": {
       "types": "./dist/client.d.ts",
       "import": "./dist/client.js"
@@ -49,24 +61,22 @@
     "access": "public"
   },
   "dependencies": {
-    "@nanostores/preact": "1.1.0",
+    "@nanostores/preact": "1.1.1",
     "@orpc/client": "2.0.0-beta.40",
     "@orpc/contract": "2.0.0-beta.40",
-    "cosmiconfig": "^10.0.1",
     "drizzle-orm": "1.0.0-rc.4-5d5b77c",
-    "nanostores": "1.5.4",
-    "vite": "npm:@voidzero-dev/vite-plus-core@1.0.0",
+    "nanostores": "1.5.5",
     "zod": "^4.6.5"
   },
   "devDependencies": {
-    "@tailorkit/asset-delivery": "0.0.0",
     "@tailorkit/config": "0.0.0",
     "@types/node": "26.6.4",
-    "happy-dom": "^20.14.5",
-    "preact": "^11.0.0",
+    "happy-dom": "^20.14.6",
+    "preact": "^11.0.1",
     "tsup": "^8.5.1",
     "typescript": "^7.0.2",
-    "vite-plus": "1.0.0"
+    "vite": "npm:@voidzero-dev/vite-plus-core@1.1.0",
+    "vite-plus": "1.1.0"
   },
   "peerDependencies": {
     "preact": "^11.0.0"
@@ -74,6 +84,8 @@
   "scripts": {
     "build": "tsup --config tsup.config.ts && tsc -p tsconfig.build.json",
     "check-types": "tsc --noEmit",
-    "test": "vp test run"
+    "test": "vp test run",
+    "lint": "vp lint .",
+    "lint:fix": "vp lint --fix ."
   }
 }

package/dist/builder/client-views.d.ts

@@ -1,16 +0,0 @@
-import type { InstanceRegistration } from "./instances";
-export declare function readClientViews(filename: string): Promise<{
-    slot: string;
-    path: string;
-    instances?: true | undefined;
-    disabled?: true | undefined;
-}[]>;
-export declare function readClientManifest(filename: string): Promise<{
-    views: {
-        slot: string;
-        path: string;
-        instances?: true | undefined;
-        disabled?: true | undefined;
-    }[];
-    instanceResolvers: InstanceRegistration[];
-}>;

package/dist/builder/database-paths.d.ts

@@ -1,4 +0,0 @@
-export declare function appDatabasePaths(root: string, migrations?: string): {
-    schema: string;
-    migrations: string;
-};

package/dist/builder/define-view.d.ts

@@ -1,3 +0,0 @@
-import type { ESTree } from "vite";
-/** Recognize the same SDK calls in route inference and instance extraction. */
-export declare function createDefineViewMatcher(program: ESTree.Program): (node: ESTree.Node) => node is ESTree.CallExpression;

package/dist/builder/drizzle.d.ts

@@ -1,2 +0,0 @@
-/** Use the app's Drizzle version with explicit flags; no Drizzle config file is needed. */
-export declare function drizzleGenerateArguments(root: string, output: string, name?: string): Promise<string[]>;

package/dist/builder/file-routes.d.ts

@@ -1,34 +0,0 @@
-import type { Plugin } from "vite";
-export declare function fileViewLocation(filename: string, root: string): {
-    slot: string;
-    path: string;
-} | undefined;
-/** Fill missing defineView options before instance extraction, on both build sides. */
-export declare function inferFileView(source: string, filename: string, root: string): string;
-export declare function discoverFileRoutes(root: string): Promise<{
-    root: {
-        filename: string;
-    } | undefined;
-    roots: {
-        filename: string;
-        slot: string;
-    }[];
-    layouts: {
-        filename: string;
-        slot: string;
-        path: string;
-    }[];
-    views: {
-        filename: string;
-        slot: string;
-    }[];
-}>;
-/** Root, layout, view and binding sources to check before deployment. */
-export declare function getClientSourceFiles(root: string): Promise<string[]>;
-/** A generated entry in build output lets the bundler track imports normally.
- * Directory watching also covers routes that did not exist at the first build. */
-export declare function createFileRouteEntry(root: string, output: string, watching: boolean): Promise<{
-    entry: string;
-    close(): Promise<void>;
-}>;
-export declare function fileRoutesPlugin(root: string): Plugin;

package/dist/builder/generate-migrations.d.ts

@@ -1,6 +0,0 @@
-export interface GenerateAppMigrationsOptions {
-    configPath?: string;
-    cwd?: string;
-    name?: string;
-}
-export declare function generateAppMigrations(options?: GenerateAppMigrationsOptions): Promise<string>;

package/dist/builder/index.d.ts

@@ -1,11 +0,0 @@
-export { createTailorKitUploadManifest, tailorkitUploadManifestSchema, type TailorKitUploadManifest, } from "./upload-manifest";
-export { generateAppMigrations, type GenerateAppMigrationsOptions } from "./generate-migrations";
-export { getClientSourceFiles } from "./file-routes";
-export interface BuildAppOptions {
-    configPath?: string;
-    cwd?: string;
-    mode?: string;
-    outDir?: string;
-    watch?: boolean;
-}
-export declare const buildApp: (options?: BuildAppOptions) => Promise<unknown>;

package/dist/builder/instances.d.ts

@@ -1,19 +0,0 @@
-import type { Plugin } from "vite";
-export interface InstanceModule {
-    filename: string;
-    names: string[];
-}
-export interface InstanceRegistration {
-    slot: string;
-    path: string;
-    resolver: string;
-}
-export declare function extractInstances(filename: string, source: string, root: string, includedNames?: string[]): Promise<{
-    names: string[];
-    server: string;
-    browser: string;
-} | undefined>;
-export declare function instanceExtractionPlugin(root: string, serverConfigured: boolean, modules: Map<string, InstanceModule>): Plugin;
-export declare function instanceServerPlugin(root: string, modules: InstanceModule[]): Plugin;
-export declare function instanceServerImports(modules: InstanceModule[]): string;
-export declare function instanceServerBindings(modules: InstanceModule[], registrations: InstanceRegistration[]): string;

package/dist/builder/migrations.d.ts

@@ -1,6 +0,0 @@
-import type { AppMigration } from "../protocol";
-/** Read the timestamped migration folders produced by the workspace's Drizzle Kit version. */
-export declare function readAppMigrations(directory: string, optional?: boolean): Promise<{
-    migrations: AppMigration[];
-    files: string[];
-}>;

package/dist/builder/schema-check.d.ts

@@ -1,2 +0,0 @@
-/** Generate a fresh snapshot with Drizzle in disposable storage, leaving committed history unchanged. */
-export declare function checkAppSchema(root: string, migrationsDirectory: string): Promise<void>;

package/dist/builder/server.d.ts

@@ -1,6 +0,0 @@
-import type { LoadedTailorKitConfig } from "../config/loader";
-import type { InstanceModule, InstanceRegistration } from "./instances";
-/** Bundle the private app backend and migrations. */
-export declare function buildServer(loaded: LoadedTailorKitConfig, watch?: boolean, buildOutDir?: string, instances?: InstanceModule[], registrations?: InstanceRegistration[]): Promise<import("@voidzero-dev/vite-plus-core/rolldown").RolldownOutput[] | import("@voidzero-dev/vite-plus-core/rolldown").RolldownOutput | import("@voidzero-dev/vite-plus-core/rolldown").RolldownWatcher | undefined>;
-/** Check before either build can empty an output directory. */
-export declare function validateServerBuildOutput(loaded: LoadedTailorKitConfig, output: string): void;

package/dist/builder/upload-manifest.d.ts

@@ -1,20 +0,0 @@
-import { z } from "zod";
-export declare const tailorkitUploadManifestSchema: z.ZodObject<{
-    assets: z.ZodObject<{
-        client: z.ZodLiteral<"client/client.js">;
-        server: z.ZodOptional<z.ZodLiteral<"server/server.js">>;
-        logos: z.ZodOptional<z.ZodObject<{
-            dark: z.ZodOptional<z.ZodString>;
-            light: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
-    views: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        slot: z.ZodString;
-        path: z.ZodString;
-        instances: z.ZodOptional<z.ZodLiteral<true>>;
-        disabled: z.ZodOptional<z.ZodLiteral<true>>;
-    }, z.core.$strip>>>;
-    version: z.ZodLiteral<1>;
-}, z.core.$strip>;
-export type TailorKitUploadManifest = z.output<typeof tailorkitUploadManifestSchema>;
-export declare const createTailorKitUploadManifest: (logos?: TailorKitUploadManifest["assets"]["logos"], server?: boolean, views?: TailorKitUploadManifest["views"]) => TailorKitUploadManifest;