@tailorkit/app 0.1.0-beta.8 → 1.0.0-beta.44

package/dist/client/session.d.ts

@@ -0,0 +1,20 @@
+import * as v from "valibot";
+import type { Identity } from "#server/functions";
+export declare const parseSession: (value: Parameters<typeof v.parse>[1]) => 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>;

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-MYK3WL3S.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-YFKW5FBP.js";
+import {
+  createApi,
+  createClient,
+  createSessionProvider,
+  reference
+} from "./chunk-MYK3WL3S.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,71 +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, TChildren extends boolean = false>(name: string, options?: {
-    callbacks?: Record<string, number>;
-    children?: TChildren;
-}) => View<TProps & {
-    children?: TChildren extends true ? ComponentChildren : never;
-}>;
-export {};
+export * from "./client";
+export * from "./server";

package/dist/index.js

@@ -1,78 +1,94 @@
-// src/index.ts
-import { createContext, h, render } from "preact";
-import { useContext } from "preact/hooks";
-var preactVersion = "10.29.8";
-var createScreen = (path, options) => {
-  const Context = createContext(null);
-  const Screen = (props) => {
-    if (props.status === "loading") {
-      return options.loading ? h(options.loading, {}) : null;
-    }
-    if (props.status === "error") {
-      return options.error ? h(options.error, {}) : null;
-    }
-    return h(
-      Context.Provider,
-      { value: props.context },
-      h(options.component, {})
-    );
-  };
-  return {
-    component: Screen,
-    path,
-    useContext: () => {
-      const context = useContext(Context);
-      if (context === null) {
-        throw new Error(`Screen context is only available while rendering "${path}".`);
-      }
-      return context;
-    }
-  };
-};
-var defineClient = (client) => ({
-  ...client,
-  $meta: {
-    preactVersion
-  },
-  $runtime: {
-    h,
-    render
-  }
-});
-var componentTagPrefix = "tailorkit-";
-var toComponentTagName = (name) => `${componentTagPrefix}${name.replaceAll(/([a-z0-9])([A-Z])/gu, "$1-$2").replaceAll(/[\s_]+/gu, "-").toLowerCase()}`;
-var toCallbackEventName = (name) => `tailorkitcallback${name.replaceAll(/[^A-Za-z0-9_$]/gu, "").toLowerCase()}`;
-var toEventProp = (event) => `on${event}`;
-var createRemoteComponent = (name, options = {}) => {
-  const tagName = toComponentTagName(name);
-  const callbacks = options.callbacks ?? {};
-  return function RemoteComponent({ children, ...props }) {
-    const nextProps = { ...props };
-    const callbackMap = {};
-    for (const [key, inputCount] of Object.entries(callbacks)) {
-      const callback = nextProps[key];
-      Reflect.deleteProperty(nextProps, key);
-      if (typeof callback !== "function") {
-        continue;
-      }
-      const eventName = toCallbackEventName(key);
-      callbackMap[eventName] = { callback: key, inputCount };
-      nextProps[toEventProp(eventName)] = (event) => {
-        callback(...(event.detail ?? []).slice(0, inputCount));
-      };
-    }
-    const serializedProps = Object.fromEntries(
-      Object.entries(nextProps).filter(([, value]) => typeof value !== "function")
-    );
-    nextProps["data-tailorkit-props"] = JSON.stringify(serializedProps);
-    if (Object.keys(callbackMap).length > 0) {
-      nextProps["data-tailorkit-callbacks"] = JSON.stringify(callbackMap);
-    }
-    return h(tagName, nextProps, options.children ? children : void 0);
-  };
-};
+import {
+  ClientProvider,
+  Route,
+  callTool,
+  createFileClient,
+  createRemoteComponent,
+  defineRoute,
+  defineView,
+  useAction,
+  useMutation,
+  useQuery
+} from "./chunk-YFKW5FBP.js";
+import {
+  createApi,
+  createClient,
+  createSessionProvider,
+  reference
+} from "./chunk-MYK3WL3S.js";
+import {
+  action,
+  and,
+  asc,
+  boolean,
+  count,
+  defineDatabase,
+  defineServer,
+  desc,
+  eq,
+  fn,
+  gt,
+  gte,
+  inArray,
+  integer,
+  isNotNull,
+  isNull,
+  lt,
+  lte,
+  mutation,
+  ne,
+  or,
+  query,
+  real,
+  table,
+  text,
+  withInstanceResolvers
+} from "./chunk-QDZXHVTU.js";
+import {
+  AppError,
+  appError
+} from "./chunk-7ZQPXG7O.js";
 export {
+  AppError,
+  ClientProvider,
+  Route,
+  action,
+  and,
+  appError,
+  asc,
+  boolean,
+  callTool,
+  count,
+  createApi,
+  createClient,
+  createFileClient,
   createRemoteComponent,
-  createScreen,
-  defineClient
+  createSessionProvider,
+  defineDatabase,
+  defineRoute,
+  defineServer,
+  defineView,
+  desc,
+  eq,
+  fn,
+  gt,
+  gte,
+  inArray,
+  integer,
+  isNotNull,
+  isNull,
+  lt,
+  lte,
+  mutation,
+  ne,
+  or,
+  query,
+  real,
+  reference,
+  table,
+  text,
+  useAction,
+  useMutation,
+  useQuery,
+  withInstanceResolvers
 };

package/dist/preact.d.ts

@@ -0,0 +1,52 @@
+import type { ComponentChildren } from "preact";
+import type { Client } from "./client/connection";
+import { QueryStore } from "./client/query-store";
+import type { QueryState } from "./client/query-store";
+import type { Reference } from "./client/reference";
+import type { AppError } from "./errors";
+export interface ClientProviderProps {
+    children?: ComponentChildren;
+    /** Supply a client for custom transport configuration. Caller-owned clients are not closed. */
+    client?: Client;
+    onError?: (error: AppError) => void;
+}
+export declare const ClientProvider: ({ children, client, onError, }: ClientProviderProps) => import("preact").VNode<import("preact").Attributes & {
+    value: QueryStore | null;
+    children?: ComponentChildren;
+}>;
+export interface QueryOptions {
+    enabled?: boolean;
+}
+type InputArguments<I> = undefined extends I ? [input?: I] : [input: I];
+type QueryArguments<I> = undefined extends I ? [input?: I, options?: QueryOptions] : [input: I, options?: QueryOptions];
+export interface QueryResult<T> extends QueryState<T> {
+    isPending: boolean;
+    isLoading: boolean;
+    isSuccess: boolean;
+    isError: boolean;
+}
+export declare const useQuery: <I, O>(ref: Reference<"query", I, O>, ...[input, options]: QueryArguments<NoInfer<I>>) => QueryResult<O>;
+export interface CallOptions<I, O> {
+    onSuccess?: (data: O, input: I) => void;
+    onError?: (error: AppError, input: I) => void;
+}
+export interface CallState<T> {
+    data: T | undefined;
+    error: AppError | null;
+    status: "idle" | "pending" | "success" | "error";
+    isPending: boolean;
+    isSuccess: boolean;
+    isError: boolean;
+    reset: () => void;
+}
+export interface MutationResult<I, O> extends CallState<O> {
+    mutate: (...args: InputArguments<I>) => void;
+    mutateAsync: (...args: InputArguments<I>) => Promise<O>;
+}
+export declare const useMutation: <I, O>(ref: Reference<"mutation", I, O>, options?: CallOptions<I, O>) => MutationResult<I, O>;
+export interface ActionResult<I, O> extends CallState<O> {
+    execute: (...args: InputArguments<I>) => void;
+    executeAsync: (...args: InputArguments<I>) => Promise<O>;
+}
+export declare const useAction: <I, O>(ref: Reference<"action", I, O>, options?: CallOptions<I, O>) => ActionResult<I, O>;
+export {};

package/dist/protocol.d.ts

@@ -0,0 +1,74 @@
+import type { ContractRouterClient } from "@orpc/contract";
+import * as v from "valibot";
+export declare const invocationSchema: v.StrictObjectSchema<{
+    readonly args: v.OptionalSchema<v.UnknownSchema, undefined>;
+    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 512, undefined>, v.RegexAction<string, undefined>]>;
+}, undefined>;
+export type Invocation = v.InferOutput<typeof invocationSchema>;
+export type MutationInvocation = Invocation & {
+    requestId: string;
+};
+/** Public wire contract; implementations and clients both depend on this definition. */
+export declare const appContract: {
+    actions: import("@orpc/contract").ProcedureContractBuilderWithInputOutput<v.StrictObjectSchema<{
+        readonly args: v.OptionalSchema<v.UnknownSchema, undefined>;
+        readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 512, undefined>, v.RegexAction<string, undefined>]>;
+    }, undefined>, import("@orpc/contract").Schema<unknown, unknown>, {
+        BAD_REQUEST: {};
+        CONFLICT: {};
+        FORBIDDEN: {};
+        INCOMPATIBLE_VERSION: {};
+        INTERNAL_SERVER_ERROR: {};
+        NOT_FOUND: {};
+        UNAUTHORIZED: {};
+        UNAVAILABLE: {};
+    }>;
+    mutations: import("@orpc/contract").ProcedureContractBuilderWithInputOutput<v.StrictObjectSchema<{
+        readonly args: v.OptionalSchema<v.UnknownSchema, undefined>;
+        readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 512, undefined>, v.RegexAction<string, undefined>]>;
+        readonly requestId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>]>;
+    }, undefined>, import("@orpc/contract").Schema<unknown, unknown>, {
+        BAD_REQUEST: {};
+        CONFLICT: {};
+        FORBIDDEN: {};
+        INCOMPATIBLE_VERSION: {};
+        INTERNAL_SERVER_ERROR: {};
+        NOT_FOUND: {};
+        UNAUTHORIZED: {};
+        UNAVAILABLE: {};
+    }>;
+    queries: import("@orpc/contract").ProcedureContractBuilderWithInputOutput<v.StrictObjectSchema<{
+        readonly args: v.OptionalSchema<v.UnknownSchema, undefined>;
+        readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 512, undefined>, v.RegexAction<string, undefined>]>;
+    }, undefined>, import("@orpc/contract").Schema<unknown, unknown>, {
+        BAD_REQUEST: {};
+        CONFLICT: {};
+        FORBIDDEN: {};
+        INCOMPATIBLE_VERSION: {};
+        INTERNAL_SERVER_ERROR: {};
+        NOT_FOUND: {};
+        UNAUTHORIZED: {};
+        UNAVAILABLE: {};
+    }>;
+    subscribe: import("@orpc/contract").ProcedureContractBuilderWithInputOutput<v.StrictObjectSchema<{
+        readonly args: v.OptionalSchema<v.UnknownSchema, undefined>;
+        readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 512, undefined>, v.RegexAction<string, undefined>]>;
+    }, undefined>, import("@orpc/contract").Schema<AsyncIterableIterator<unknown>, AsyncIterableIterator<unknown>>, {
+        BAD_REQUEST: {};
+        CONFLICT: {};
+        FORBIDDEN: {};
+        INCOMPATIBLE_VERSION: {};
+        INTERNAL_SERVER_ERROR: {};
+        NOT_FOUND: {};
+        UNAUTHORIZED: {};
+        UNAVAILABLE: {};
+    }>;
+};
+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,39 @@
+// src/protocol.ts
+import { oc, type } from "@orpc/contract";
+import * as v from "valibot";
+var invocationSchema = v.strictObject({
+  args: v.optional(v.unknown()),
+  name: v.pipe(
+    v.string(),
+    v.maxLength(512),
+    v.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: {},
+  CONFLICT: {},
+  FORBIDDEN: {},
+  INCOMPATIBLE_VERSION: {},
+  INTERNAL_SERVER_ERROR: {},
+  NOT_FOUND: {},
+  UNAUTHORIZED: {},
+  UNAVAILABLE: {}
+});
+var appContract = {
+  actions: procedure.input(invocationSchema).output(type()),
+  mutations: procedure.input(
+    v.strictObject({
+      ...invocationSchema.entries,
+      requestId: v.pipe(v.string(), v.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())
+};
+export {
+  appContract,
+  invocationSchema
+};

package/dist/routing.d.ts

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