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

package/dist/chunk-YX3JURMG.js

@@ -0,0 +1,262 @@
+import {
+  AppError
+} from "./chunk-7ZQPXG7O.js";
+
+// src/server/functions.ts
+var query = (definition) => Object.freeze({ ...definition, kind: "query" });
+var mutation = (definition) => Object.freeze({ ...definition, kind: "mutation" });
+var action = (definition) => Object.freeze({ ...definition, kind: "action" });
+var isFunction = (value) => typeof value.kind === "string" && typeof value.handler === "function";
+var defineServer = (functions) => {
+  for (const [name, value] of Object.entries(functions)) {
+    if (!/^[a-zA-Z][a-zA-Z0-9_]{0,63}$/u.test(name)) {
+      throw new Error("Invalid function name");
+    }
+    if (!isFunction(value)) {
+      defineServer(value);
+    }
+  }
+  return Object.freeze({ functions });
+};
+
+// src/database/definition.ts
+var defineDatabase = (definition) => Object.freeze({ relations: definition.relations });
+
+// src/server/builder.ts
+import { z } from "zod";
+var FunctionBuilder = class _FunctionBuilder {
+  kind;
+  args;
+  result;
+  calls;
+  databaseDefinition;
+  constructor(kind, args, result, calls, database) {
+    this.kind = kind;
+    this.args = args;
+    this.result = result;
+    this.calls = calls;
+    this.databaseDefinition = database;
+  }
+  input(schema) {
+    return new _FunctionBuilder(
+      this.kind,
+      schema,
+      this.result,
+      this.calls,
+      this.databaseDefinition
+    );
+  }
+  output(schema) {
+    return new _FunctionBuilder(
+      this.kind,
+      this.args,
+      schema,
+      this.calls,
+      this.databaseDefinition
+    );
+  }
+  functions(functions) {
+    return new _FunctionBuilder(
+      this.kind,
+      this.args,
+      this.result,
+      functions,
+      this.databaseDefinition
+    );
+  }
+  database(database) {
+    return new _FunctionBuilder(
+      this.kind,
+      this.args,
+      this.result,
+      this.calls,
+      database
+    );
+  }
+  handler(handler) {
+    const metadata = {};
+    if (this.databaseDefinition) {
+      metadata.database = this.databaseDefinition;
+    }
+    if (this.result) {
+      metadata.result = this.result;
+    }
+    if (this.kind === "action") {
+      metadata.functions = this.calls;
+    }
+    return (
+      /* oxlint-disable typescript/no-unsafe-type-assertion, anti-slop/no-chained-type-assertions -- This builder or fixture preserves the declared capabilities across an erased generic boundary. */
+      Object.freeze({
+        ...metadata,
+        args: this.args,
+        handler: (context) => (
+          // SAFETY: The adapter reconstructs the same runtime contract, but TypeScript cannot relate the erased generic parameters across this library boundary.
+          // oxlint-disable-next-line anti-slop/no-chained-type-assertions -- The adapter reconstructs the same runtime contract, but TypeScript cannot relate the erased generic parameters across this library boundary.
+          handler({
+            ...context,
+            input: context.args
+          })
+        ),
+        kind: this.kind
+      })
+    );
+  }
+};
+var fn = Object.freeze({
+  action: new FunctionBuilder("action", z.undefined(), void 0, {}),
+  mutation: new FunctionBuilder("mutation", z.undefined(), void 0, {}),
+  query: new FunctionBuilder("query", z.undefined(), void 0, {})
+});
+
+// src/server/instances.ts
+import { z as z2 } from "zod";
+var addressSchema = z2.object({
+  path: z2.string().startsWith("/").max(1024),
+  slot: z2.string().min(1).max(255)
+});
+var registeredQueries = (functions) => {
+  const queries = {};
+  for (const [name, fn2] of Object.entries(functions)) {
+    if (isFunction(fn2)) {
+      if (fn2.kind === "query") {
+        queries[name] = fn2;
+      }
+    } else {
+      const nested = registeredQueries(fn2);
+      if (Object.keys(nested).length) {
+        queries[name] = nested;
+      }
+    }
+  }
+  return queries;
+};
+var withInstanceResolvers = (app, resolvers) => {
+  if (Object.hasOwn(app.functions, "_tailorkit")) {
+    throw new Error(
+      "The _tailorkit function namespace is reserved by TailorKit."
+    );
+  }
+  const queries = registeredQueries(app.functions);
+  const registry = /* @__PURE__ */ new Map();
+  for (const resolver of resolvers) {
+    addressSchema.parse(resolver);
+    let paths = registry.get(resolver.slot);
+    if (!paths) {
+      paths = /* @__PURE__ */ new Map();
+      registry.set(resolver.slot, paths);
+    }
+    if (paths.has(resolver.path)) {
+      throw new Error(
+        `Duplicate instance resolver for slot "${resolver.slot}" and path "${resolver.path}".`
+      );
+    }
+    const result = z2.array(
+      z2.object({
+        data: resolver.dataSchema,
+        key: z2.string().min(1),
+        metadata: z2.record(z2.string(), z2.unknown())
+      })
+    ).refine(
+      (items) => new Set(items.map((item) => item.key)).size === items.length,
+      {
+        message: "Instance keys must be unique"
+      }
+    );
+    paths.set(resolver.path, { resolver, result });
+  }
+  const instances = {
+    resolve: action({
+      args: addressSchema.extend({
+        context: z2.record(z2.string(), z2.unknown())
+      }),
+      functions: queries,
+      handler: async ({ args, identity, signal, queries: queriesValue }) => {
+        const entry = registry.get(args.slot)?.get(args.path);
+        if (!entry) {
+          throw new AppError("NOT_FOUND", "Instance resolver not found");
+        }
+        const value = await entry.resolver.resolve({
+          context: args.context,
+          identity,
+          queries: queriesValue,
+          signal
+        });
+        const result = entry.result.safeParse(value);
+        if (!result.success) {
+          throw new AppError(
+            "INTERNAL_SERVER_ERROR",
+            "Invalid function result"
+          );
+        }
+        return result.data;
+      }
+    })
+  };
+  const internal = defineServer({ instances });
+  return Object.freeze({
+    functions: { ...app.functions, _tailorkit: internal.functions }
+  });
+};
+
+// src/database/schema.ts
+import {
+  sqliteTable,
+  text as sqliteText,
+  integer as sqliteInteger,
+  real as sqliteReal
+} from "drizzle-orm/sqlite-core";
+import {
+  eq,
+  ne,
+  gt,
+  gte,
+  lt,
+  lte,
+  and,
+  or,
+  asc,
+  desc,
+  count,
+  isNull,
+  isNotNull,
+  inArray
+} from "drizzle-orm";
+var table = (name, columns) => {
+  if (!/^[a-zA-Z][a-zA-Z0-9_]{0,62}$/u.test(name) || name.startsWith("sqlite_") || name.startsWith("tailorkit_")) {
+    throw new Error("Invalid or reserved table name");
+  }
+  return sqliteTable(name, columns);
+};
+var text = (name = "") => sqliteText(name);
+var integer = (name = "") => sqliteInteger(name);
+var real = (name = "") => sqliteReal(name);
+var boolean = (name = "") => sqliteInteger(name, { mode: "boolean" });
+
+export {
+  query,
+  mutation,
+  action,
+  defineServer,
+  defineDatabase,
+  fn,
+  withInstanceResolvers,
+  table,
+  text,
+  integer,
+  real,
+  boolean,
+  eq,
+  ne,
+  gt,
+  gte,
+  lt,
+  lte,
+  and,
+  or,
+  asc,
+  desc,
+  count,
+  isNull,
+  isNotNull,
+  inArray
+};

package/dist/client/connection.d.ts

@@ -0,0 +1,31 @@
+import { AppError } from "#errors";
+import type { Reference } from "./reference";
+import type { Session } from "./session";
+export type { Session } from "./session";
+export { reference } from "./reference";
+export type { Reference, References } from "./reference";
+export { AppError } from "#errors";
+type InputArguments<I> = undefined extends I ? [args?: I] : [args: I];
+type MutationArguments<I> = undefined extends I ? [args?: I, options?: {
+    requestId?: string;
+}] : [args: I, options?: {
+    requestId?: string;
+}];
+export interface Client {
+    query: <I, O>(reference: Reference<"query", I, O>, ...args: InputArguments<NoInfer<I>>) => Promise<O>;
+    mutate: <I, O>(reference: Reference<"mutation", I, O>, ...args: MutationArguments<NoInfer<I>>) => Promise<O>;
+    action: <I, O>(reference: Reference<"action", I, O>, ...args: InputArguments<NoInfer<I>>) => Promise<O>;
+    subscribe: <I, O>(reference: Reference<"query", I, O>, args: NoInfer<I>, next: (value: O) => void, options?: {
+        onError?: (error: AppError) => void;
+    }) => () => void;
+    close: () => void;
+}
+export declare const createClient: (options?: {
+    getSession?: (options: {
+        refresh: boolean;
+    }) => Promise<Session>;
+    connect?: (url: string, protocols: string[]) => WebSocket | Promise<WebSocket>;
+    fetch?: typeof fetch;
+    retryDelayMs?: number;
+}) => Client;
+export { createSessionProvider, parseSession } from "./session";

package/dist/client/query-store.d.ts

@@ -0,0 +1,23 @@
+import type { AppError } from "#errors";
+import type { Client } from "./connection";
+import type { Reference } from "./reference";
+export interface QueryState<T> {
+    data: T | undefined;
+    error: AppError | null;
+    status: "pending" | "success" | "error";
+}
+export declare const pendingQuery: QueryState<never>;
+export declare const serializeInput: (input: unknown) => string;
+/** One subscription per active query/input pair, scoped to this provider's client. */
+export declare class QueryStore {
+    readonly state: import("nanostores").PreinitializedWritableAtom<Map<string, QueryState<unknown>>> & object;
+    private readonly entries;
+    private disposed;
+    readonly client: Client;
+    private readonly ownsClient;
+    private readonly errorHandler;
+    constructor(client: Client, ownsClient: boolean, errorHandler?: (error: AppError) => void);
+    watch<I, O>(key: string, ref: Reference<"query", I, O>, input: I): () => void;
+    dispose(): void;
+    onError(error: AppError): void;
+}

package/dist/client/reference.d.ts

@@ -0,0 +1,20 @@
+import type { z } from "zod";
+import type { FunctionResult, Functions } from "#server/functions";
+export interface Reference<K extends "query" | "mutation" | "action", I, O> {
+    readonly name: string;
+    readonly $types?: {
+        kind: K;
+        input: I;
+        output: O;
+    };
+}
+export declare const reference: <K extends "query" | "mutation" | "action", I, O>(name: string, _kind: K) => Reference<K, I, O>;
+export type References<F> = {
+    readonly [N in keyof F]: F[N] extends {
+        kind: infer K extends "query" | "mutation" | "action";
+        args: infer A extends z.ZodType;
+        handler: (...args: never[]) => infer _Output;
+    } ? Reference<K, z.input<A>, FunctionResult<F[N]>> : F[N] extends Functions ? References<F[N]> : never;
+};
+/** Browser references inferred directly from the server's exported function type. */
+export declare const createApi: <F extends Functions>() => References<F>;

package/dist/client/session.d.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import type { Identity } from "#server/functions";
+declare const sessionSchema: z.ZodObject<{
+    expiresAt: z.ZodNumber;
+    identity: z.ZodOptional<z.ZodObject<{
+        appId: z.ZodString;
+        deploymentId: z.ZodString;
+        expiresAt: z.ZodNumber;
+        installationId: z.ZodString;
+        projectId: z.ZodString;
+        scope: z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        }, z.core.$strip>;
+        subjectId: z.ZodOptional<z.ZodString>;
+        toolUrl: z.ZodString;
+    }, z.core.$strip>>;
+    subjectId: z.ZodOptional<z.ZodString>;
+    token: z.ZodString;
+    toolUrl: z.ZodOptional<z.ZodString>;
+    url: z.ZodString;
+}, z.core.$strip>;
+export declare const parseSession: (value: Parameters<typeof sessionSchema.parse>[0]) => Session;
+export interface Session {
+    toolUrl?: string;
+    identity?: Identity;
+    subjectId?: string;
+    token: string;
+    expiresAt: number;
+    url: string;
+}
+export declare const sessionRenewalDelay: (session: Session) => number;
+/** Host-owned provider: project credentials never cross into the sandbox. */
+export declare const createSessionProvider: (options: {
+    baseUrl: string | URL;
+    appId: string;
+    fetch?: typeof fetch;
+}) => (input: {
+    refresh: boolean;
+}) => Promise<Session>;
+export {};

package/dist/client/tools.d.ts

@@ -0,0 +1,16 @@
+import type { Session } from "./session";
+export interface ToolBridge<TInput = unknown, TOutput = unknown> {
+    client: (path: string, input: TInput) => Promise<TOutput>;
+    session: (path: string) => Promise<Session>;
+}
+declare global {
+    var __tailorkitTools: ToolBridge | undefined;
+    var __tailorkitBackendSession: ((options: {
+        refresh: boolean;
+    }) => Promise<Session>) | undefined;
+}
+export interface TailorKitServerTools {
+}
+export declare const executeServerTool: (session: Session, path: string, input: unknown, request?: typeof fetch, signal?: AbortSignal) => Promise<unknown>;
+/** Generated callers delegate only transport; host/server declarations validate both directions. */
+export declare const callTool: (kind: "client" | "server", path: string, input?: Parameters<ToolBridge["client"]>[1]) => ReturnType<ToolBridge["client"]>;

package/dist/client-connection.js

@@ -0,0 +1,16 @@
+import {
+  createClient,
+  createSessionProvider,
+  parseSession,
+  reference
+} from "./chunk-PJBDA2RU.js";
+import {
+  AppError
+} from "./chunk-7ZQPXG7O.js";
+export {
+  AppError,
+  createClient,
+  createSessionProvider,
+  parseSession,
+  reference
+};

package/dist/client.d.ts

@@ -0,0 +1,11 @@
+export * from "./views";
+export * from "./preact";
+export { defineRoute, Route, createFileClient } from "./routing";
+export type { RouteDefinition, ShellProps } from "./routing";
+export { createClient, createSessionProvider, reference, } from "./client/connection";
+export { createApi } from "./client/reference";
+export type { Client, Session, Reference, References, } from "./client/connection";
+export { AppError, appError } from "./errors";
+export type { ErrorCode } from "./errors";
+export { callTool } from "./client/tools";
+export type { TailorKitServerTools, ToolBridge } from "./client/tools";

package/dist/client.js

@@ -0,0 +1,40 @@
+import {
+  ClientProvider,
+  Route,
+  callTool,
+  createFileClient,
+  createRemoteComponent,
+  defineRoute,
+  defineView,
+  useAction,
+  useMutation,
+  useQuery
+} from "./chunk-UDXPIO6D.js";
+import {
+  createApi,
+  createClient,
+  createSessionProvider,
+  reference
+} from "./chunk-PJBDA2RU.js";
+import {
+  AppError,
+  appError
+} from "./chunk-7ZQPXG7O.js";
+export {
+  AppError,
+  ClientProvider,
+  Route,
+  appError,
+  callTool,
+  createApi,
+  createClient,
+  createFileClient,
+  createRemoteComponent,
+  createSessionProvider,
+  defineRoute,
+  defineView,
+  reference,
+  useAction,
+  useMutation,
+  useQuery
+};

package/dist/database/definition.d.ts

@@ -0,0 +1,8 @@
+import type { AnyRelations } from "drizzle-orm/relations";
+export interface DatabaseDefinition<R extends AnyRelations = AnyRelations> {
+    readonly relations: R;
+}
+/** Configure the installation database with Drizzle relations, which also contain its tables. */
+export declare const defineDatabase: <const R extends AnyRelations>(definition: DatabaseDefinition<R>) => Readonly<{
+    relations: R;
+}>;

package/dist/database/schema.d.ts

@@ -0,0 +1,78 @@
+import type { ColumnBuilderBase } from "drizzle-orm";
+export declare const table: <N extends string, C extends Record<string, ColumnBuilderBase>>(name: N, columns: C) => import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: N;
+    schema: undefined;
+    columns: { [Key in keyof C]: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: string;
+        tableName: N;
+        dataType: C[Key]["_"]["dataType"];
+        data: C[Key]["_"] extends infer T ? T extends C[Key]["_"] ? T extends {
+            $type: infer U;
+        } ? U : T["data"] : never : never;
+        driverParam: C[Key]["_"]["driverParam"];
+        notNull: C[Key]["_"]["notNull"] extends true ? true : false;
+        hasDefault: C[Key]["_"]["hasDefault"] extends true ? true : false;
+        isPrimaryKey: C[Key]["_"] extends infer T_1 ? T_1 extends C[Key]["_"] ? T_1 extends {
+            isPrimaryKey: true;
+        } ? true : false : never : never;
+        isAutoincrement: C[Key]["_"] extends infer T_2 ? T_2 extends C[Key]["_"] ? T_2 extends {
+            isAutoincrement: true;
+        } ? true : false : never : never;
+        hasRuntimeDefault: C[Key]["_"] extends infer T_3 ? T_3 extends C[Key]["_"] ? T_3 extends {
+            hasRuntimeDefault: true;
+        } ? true : false : never : never;
+        enumValues: C[Key]["_"] extends infer T_4 ? T_4 extends C[Key]["_"] ? T_4 extends {
+            enumValues: [string, ...string[]];
+        } ? T_4["enumValues"] : undefined : never : never;
+        baseColumn: C[Key]["_"] extends infer T_5 ? T_5 extends C[Key]["_"] ? T_5 extends {
+            baseBuilder: infer U_1 extends ColumnBuilderBase;
+        } ? import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: N;
+            dataType: U_1["_"]["dataType"];
+            data: U_1["_"] extends infer T_6 ? T_6 extends U_1["_"] ? T_6 extends {
+                $type: infer U;
+            } ? U : T_6["data"] : never : never;
+            driverParam: U_1["_"]["driverParam"];
+            notNull: U_1["_"]["notNull"] extends true ? true : false;
+            hasDefault: U_1["_"]["hasDefault"] extends true ? true : false;
+            isPrimaryKey: U_1["_"] extends infer T_7 ? T_7 extends U_1["_"] ? T_7 extends {
+                isPrimaryKey: true;
+            } ? true : false : never : never;
+            isAutoincrement: U_1["_"] extends infer T_8 ? T_8 extends U_1["_"] ? T_8 extends {
+                isAutoincrement: true;
+            } ? true : false : never : never;
+            hasRuntimeDefault: U_1["_"] extends infer T_9 ? T_9 extends U_1["_"] ? T_9 extends {
+                hasRuntimeDefault: true;
+            } ? true : false : never : never;
+            enumValues: U_1["_"] extends infer T_10 ? T_10 extends U_1["_"] ? T_10 extends {
+                enumValues: [string, ...string[]];
+            } ? T_10["enumValues"] : undefined : never : never;
+            baseColumn: U_1["_"] extends infer T_11 ? T_11 extends U_1["_"] ? T_11 extends {
+                baseBuilder: infer U_1 extends ColumnBuilderBase;
+            } ? import("drizzle-orm/sqlite-core").SQLiteColumn</*elided*/ any, {}> : never : never : never;
+            identity: U_1["_"] extends infer T_12 ? T_12 extends U_1["_"] ? T_12 extends {
+                identity: 'always';
+            } ? "always" : T_12 extends {
+                identity: 'byDefault';
+            } ? "byDefault" : undefined : never : never;
+            generated: U_1["_"] extends infer T_13 ? T_13 extends U_1["_"] ? T_13 extends {
+                generated: infer G;
+            } ? unknown extends G ? undefined : G extends undefined ? undefined : G : undefined : never : never;
+        }, {}> : never : never : never;
+        identity: C[Key]["_"] extends infer T_14 ? T_14 extends C[Key]["_"] ? T_14 extends {
+            identity: 'always';
+        } ? "always" : T_14 extends {
+            identity: 'byDefault';
+        } ? "byDefault" : undefined : never : never;
+        generated: C[Key]["_"] extends infer T_15 ? T_15 extends C[Key]["_"] ? T_15 extends {
+            generated: infer G;
+        } ? unknown extends G ? undefined : G extends undefined ? undefined : G : undefined : never : never;
+    }, {}>; };
+    dialect: 'sqlite';
+}>;
+export declare const text: (name?: string) => import("drizzle-orm/sqlite-core").SQLiteTextBuilder<[string, ...string[]]>;
+export declare const integer: (name?: string) => import("drizzle-orm/sqlite-core").SQLiteIntegerBuilder;
+export declare const real: (name?: string) => import("drizzle-orm/sqlite-core").SQLiteRealBuilder;
+export declare const boolean: (name?: string) => import("drizzle-orm/sqlite-core").SQLiteBooleanBuilder;
+export { eq, ne, gt, gte, lt, lte, and, or, asc, desc, count, isNull, isNotNull, inArray, } from "drizzle-orm";

package/dist/database/types.d.ts

@@ -0,0 +1,8 @@
+import type { AnyRelations, EmptyRelations } from "drizzle-orm/relations";
+import type { BaseSQLiteDatabase } from "drizzle-orm/sqlite-core";
+type Database<R extends AnyRelations> = BaseSQLiteDatabase<"sync", {
+    changes: number;
+}, Record<string, never>, R>;
+export type QueryDatabase<R extends AnyRelations = EmptyRelations> = Pick<Database<R>, "select" | "selectDistinct" | "query">;
+export type MutationDatabase<R extends AnyRelations = EmptyRelations> = QueryDatabase<R> & Pick<Database<R>, "insert" | "update" | "delete">;
+export {};

package/dist/errors.d.ts

@@ -0,0 +1,6 @@
+export type ErrorCode = "BAD_REQUEST" | "UNAUTHORIZED" | "FORBIDDEN" | "NOT_FOUND" | "CONFLICT" | "INCOMPATIBLE_VERSION" | "UNAVAILABLE" | "INTERNAL_SERVER_ERROR";
+export declare class AppError extends Error {
+    readonly code: ErrorCode;
+    constructor(code: ErrorCode, message?: string);
+}
+export declare const appError: (cause: unknown) => AppError;

package/dist/index.d.ts

@@ -1,72 +1,2 @@
-import { h } from "preact";
-import type { ComponentChild, ComponentChildren, VNode } from "preact";
-export interface TailorKitScreens {
-}
-export type ScreenPath = Extract<keyof TailorKitScreens & string, `/${string}`>;
-export type AppScreenPath = ScreenPath;
-export type ScreenProps<TPath extends ScreenPath> = TailorKitScreens[TPath] extends object ? TailorKitScreens[TPath] : Record<string, never>;
-export type ScreenPropsForPath<TPath extends AppScreenPath> = TPath extends ScreenPath ? ScreenProps<TPath> : never;
-export type ScreenContext<TPath extends AppScreenPath> = ScreenPropsForPath<TPath> extends {
-    context: infer TContext;
-} ? TContext : Record<string, never>;
-export type View<TProps extends object = Record<string, never>> = (props: TProps) => ComponentChild;
-export type ScreenRuntimeProps<TPath extends AppScreenPath> = {
-    context: ScreenContext<TPath>;
-    screen: TPath;
-    status: "ready";
-} | {
-    context?: never;
-    screen: TPath;
-    status: "loading";
-} | {
-    context?: never;
-    screen: TPath;
-    status: "error";
-};
-export interface ScreenDefinition<TPath extends AppScreenPath = AppScreenPath> {
-    component: View<ScreenRuntimeProps<TPath>>;
-    path: TPath;
-    useContext: () => ScreenContext<TPath>;
-}
-type RegisteredScreens = {
-    [TPath in AppScreenPath]: ScreenDefinition<TPath>;
-};
-type ScreenDefinitions = Partial<RegisteredScreens>;
-type InvalidScreenPath<TScreens> = Exclude<keyof TScreens & string, `/${string}`>;
-type RequireScreenPaths<TScreens> = InvalidScreenPath<TScreens> extends never ? unknown : {
-    readonly __tailorkit_error__: `Screen paths must start with "/". Invalid screen: ${InvalidScreenPath<TScreens>}`;
-};
-type ScreenKeyPathMismatch<TScreens> = {
-    [TPath in keyof TScreens & string]: TScreens[TPath] extends ScreenDefinition<infer TScreenPath> ? TScreenPath extends TPath ? never : TPath : TPath;
-}[keyof TScreens & string];
-type RequireMatchingScreenKeys<TScreens> = ScreenKeyPathMismatch<TScreens> extends never ? unknown : {
-    readonly __tailorkit_error__: `Screen key must match createScreen path. Invalid screen: ${ScreenKeyPathMismatch<TScreens>}`;
-};
-export interface TailorKitClient<TScreens extends ScreenDefinitions = ScreenDefinitions> {
-    screens: TScreens;
-}
-export interface TailorKitClientMeta {
-    preactVersion: string;
-}
-export interface TailorKitClientRuntime {
-    h: typeof h;
-    render: (vnode: VNode, parent: Element | Document | ShadowRoot | DocumentFragment) => void;
-}
-export type TailorKitClientWithMeta<TScreens extends ScreenDefinitions = ScreenDefinitions> = TailorKitClient<TScreens> & {
-    $meta: TailorKitClientMeta;
-    $runtime: TailorKitClientRuntime;
-};
-export declare const createScreen: <const TPath extends AppScreenPath>(path: TPath, options: {
-    component: View<Record<string, never>>;
-    error?: View<Record<string, never>>;
-    loading?: View<Record<string, never>>;
-}) => ScreenDefinition<TPath>;
-export declare const defineClient: <const TScreens extends ScreenDefinitions>(client: TailorKitClient<TScreens> & RequireScreenPaths<TScreens> & RequireMatchingScreenKeys<TScreens>) => TailorKitClientWithMeta<TScreens>;
-export declare const createRemoteComponent: <TProps extends object, TSlots extends readonly string[]>(name: string, options: {
-    callbacks?: Record<string, number>;
-    slots: TSlots;
-}) => View<TProps & {
-    children?: ComponentChildren;
-}>;
-export {};
-//# sourceMappingURL=index.d.ts.map
+export * from "./client";
+export * from "./server";