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

package/dist/chunk-YFKW5FBP.js

@@ -0,0 +1,623 @@
+import {
+  createClient,
+  reference
+} from "./chunk-MYK3WL3S.js";
+import {
+  AppError,
+  appError
+} from "./chunk-7ZQPXG7O.js";
+
+// src/views.ts
+import { createContext, h } from "preact";
+import { useContext } from "preact/hooks";
+var isFunctionValue = (value) => typeof value === "function";
+function defineView(options) {
+  if (!options.slot || !options.view) {
+    throw new Error(
+      "Views without a slot or path must be compiled from a .view.tsx file by the TailorKit app build."
+    );
+  }
+  const path = options.view;
+  const Context2 = createContext(null);
+  const instances = (
+    /* oxlint-disable typescript/no-unsafe-type-assertion -- Generated bindings associate this view path with its context and instance schema; the adapter retains that relationship while erasing renderer generics. */
+    options.instances
+  );
+  if (instances && !(instances.resolver !== void 0 && instances.resolver !== null && instances.resolver !== "")) {
+    throw new Error(
+      "View instance resolvers must be compiled with the TailorKit app build."
+    );
+  }
+  const View = (props) => {
+    if (props.status !== "ready") {
+      return null;
+    }
+    if (instances && !props.instance) {
+      throw new Error(
+        `View "${path}" requires a selected instance. Pass instanceKey to RenderSlot or instance to RenderSlot.Controlled.`
+      );
+    }
+    return h(
+      Context2.Provider,
+      {
+        value: {
+          context: props.context,
+          instance: props.instance
+        }
+      },
+      h(
+        /* oxlint-disable typescript/no-unsafe-type-assertion -- Generated bindings associate this view path with its context and instance schema; the adapter retains that relationship while erasing renderer generics. */
+        options.component,
+        /* oxlint-enable typescript/no-unsafe-type-assertion */
+        {
+          key: props.instance?.key
+        }
+      )
+    );
+  };
+  const instanceMetadata = {};
+  if (instances?.resolver !== void 0 && instances?.resolver !== null && instances?.resolver !== "") {
+    instanceMetadata.instances = { resolver: instances.resolver };
+  }
+  return {
+    ...instanceMetadata,
+    component: View,
+    path,
+    slot: options.slot,
+    useContext: () => {
+      const context = useContext(Context2);
+      if (context === null) {
+        throw new Error(
+          `View context is only available while rendering "${path}".`
+        );
+      }
+      return context.context;
+    },
+    useInstance: () => {
+      const value = useContext(Context2);
+      if (!value?.instance) {
+        throw new Error(
+          `View instance is only available while rendering an instance of "${path}".`
+        );
+      }
+      return (
+        /* oxlint-disable typescript/no-unsafe-type-assertion -- Generated bindings associate this view path with its context and instance schema; the adapter retains that relationship while erasing renderer generics. */
+        value.instance
+      );
+    }
+  };
+}
+var componentTagPrefix = "tailorkit-";
+var toComponentTagName = (name) => `${componentTagPrefix}${name.replaceAll(
+  /(?<lowercase>[a-z0-9])(?<uppercase>[A-Z])/gu,
+  "$<lowercase>-$<uppercase>"
+).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 operation = nextProps[key];
+      Reflect.deleteProperty(nextProps, key);
+      if (!isFunctionValue(operation)) {
+        continue;
+      }
+      const eventName = toCallbackEventName(key);
+      callbackMap[eventName] = { callback: key, inputCount };
+      nextProps[toEventProp(eventName)] = (event) => {
+        operation(...(event.detail ?? []).slice(0, inputCount));
+      };
+    }
+    const serializedProps = Object.fromEntries(
+      Object.entries(nextProps).filter(([, value]) => !isFunctionValue(value))
+    );
+    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 === true ? children : void 0
+    );
+  };
+};
+
+// src/preact.ts
+import { useStore } from "@nanostores/preact";
+import { atom as atom2, computed } from "nanostores";
+import { createContext as createContext2, h as h2 } from "preact";
+import {
+  useCallback,
+  useContext as useContext2,
+  useEffect,
+  useLayoutEffect,
+  useMemo,
+  useRef
+} from "preact/hooks";
+
+// src/client/query-store.ts
+import { atom } from "nanostores";
+var isObjectValue = (value) => typeof value === "object" && value !== null;
+var pendingQuery = {
+  data: void 0,
+  error: null,
+  status: "pending"
+};
+var serializeInput = (input) => JSON.stringify(
+  { defined: input !== void 0, input },
+  // Native JSON serialization supplies arbitrary values; this boundary only normalizes object key order.
+  // oxlint-disable-next-line anti-slop/no-unknown-parameters -- These are serializer inputs, not unparsed domain-handler arguments.
+  (_key, value) => {
+    if (isObjectValue(value) && !Array.isArray(value)) {
+      return Object.fromEntries(
+        Object.entries(value).toSorted(([a], [b]) => a.localeCompare(b))
+      );
+    }
+    return value;
+  }
+);
+var QueryStore = class {
+  state = atom(/* @__PURE__ */ new Map());
+  entries = /* @__PURE__ */ new Map();
+  disposed = false;
+  client;
+  ownsClient;
+  errorHandler;
+  constructor(client, ownsClient, errorHandler = () => {
+  }) {
+    this.client = client;
+    this.ownsClient = ownsClient;
+    this.errorHandler = errorHandler;
+  }
+  watch(key, ref, input) {
+    let entry = this.entries.get(key);
+    const first = !entry;
+    if (!entry) {
+      entry = { observers: 0 };
+      this.entries.set(key, entry);
+    }
+    const current = entry;
+    current.observers += 1;
+    const publish = (state) => {
+      if (!this.disposed && this.entries.get(key) === current) {
+        this.state.set(new Map(this.state.get()).set(key, state));
+      }
+    };
+    if (first) {
+      const onError = (error) => {
+        if (this.disposed || this.entries.get(key) !== current) {
+          return;
+        }
+        publish({
+          data: this.state.get().get(key)?.data,
+          error,
+          status: "error"
+        });
+        this.onError(error);
+      };
+      try {
+        current.stop = this.client.subscribe(
+          ref,
+          input,
+          (data) => {
+            publish({ data, error: null, status: "success" });
+          },
+          { onError }
+        );
+      } catch (error) {
+        onError(appError(error));
+      }
+    }
+    let active = true;
+    return () => {
+      if (!active) {
+        return;
+      }
+      active = false;
+      current.observers -= 1;
+      if (current.observers === 0 && this.entries.get(key) === current) {
+        this.entries.delete(key);
+        current.stop?.();
+        const next = new Map(this.state.get());
+        next.delete(key);
+        this.state.set(next);
+      }
+    };
+  }
+  dispose() {
+    this.disposed = true;
+    const entries = [...this.entries.values()];
+    this.entries.clear();
+    for (const entry of entries) {
+      entry.stop?.();
+      entry.stop = void 0;
+    }
+    this.state.set(/* @__PURE__ */ new Map());
+    if (this.ownsClient) {
+      this.client.close();
+    }
+  }
+  onError(error) {
+    if (!this.disposed) {
+      this.errorHandler(error);
+    }
+  }
+};
+
+// src/preact.ts
+var Context = createContext2(null);
+var ClientProvider = ({
+  children,
+  client,
+  onError
+}) => {
+  const errorHandler = useRef(onError);
+  errorHandler.current = onError;
+  const store = useMemo(
+    () => new QueryStore(
+      client ?? createClient(),
+      !client,
+      (error) => errorHandler.current?.(error)
+    ),
+    [client]
+  );
+  useLayoutEffect(
+    () => () => {
+      store.dispose();
+    },
+    [store]
+  );
+  return h2(Context.Provider, { value: store }, children);
+};
+var useQueryStore = () => {
+  const store = useContext2(Context);
+  if (!store) {
+    throw new Error(
+      "TailorKit backend hooks require a ClientProvider at the app root."
+    );
+  }
+  return store;
+};
+var useQuery = (ref, ...[input, options]) => {
+  const store = useQueryStore();
+  const enabled = options?.enabled ?? true;
+  const { name } = ref;
+  const serialized = serializeInput(input);
+  const key = `${name}\0${serialized}`;
+  const stableInput = useMemo(
+    () => (
+      /* oxlint-disable typescript/no-unsafe-type-assertion -- serializeInput produced serialized from this reference's own input; this parses local transport-normalized input rather than external JSON. */
+      JSON.parse(serialized).input
+    ),
+    [serialized]
+  );
+  const stableReference = useMemo(
+    () => reference(name, "query"),
+    [name]
+  );
+  const query = useMemo(
+    () => computed(
+      store.state,
+      (queries) => (
+        /* oxlint-disable typescript/no-unsafe-type-assertion -- This cache key identifies the same reference and serialized input, so its state is populated only by that reference's O-typed subscription. */
+        enabled ? queries.get(key) ?? pendingQuery : pendingQuery
+      )
+      /* oxlint-enable typescript/no-unsafe-type-assertion */
+    ),
+    [store, key, enabled]
+  );
+  const state = useStore(query);
+  useEffect(
+    () => enabled ? store.watch(key, stableReference, stableInput) : void 0,
+    [store, key, enabled, stableInput, stableReference]
+  );
+  return {
+    ...state,
+    isError: state.status === "error",
+    isLoading: enabled && state.status === "pending",
+    isPending: state.status === "pending",
+    isSuccess: state.status === "success"
+  };
+};
+var idleCall = { data: void 0, error: null, status: "idle" };
+var useCall = (kind, ref, options) => {
+  const store = useQueryStore();
+  const { name } = ref;
+  const identity = useMemo(
+    () => ({
+      kind,
+      name,
+      state: atom2(idleCall),
+      store
+    }),
+    [store, name, kind]
+  );
+  const state = useStore(identity.state);
+  const current = useRef({ identity, mounted: true, sequence: 0 });
+  if (current.current.identity !== identity) {
+    current.current = {
+      identity,
+      mounted: true,
+      sequence: current.current.sequence + 1
+    };
+  }
+  const callbacks = useRef(options);
+  callbacks.current = options;
+  useLayoutEffect(() => {
+    current.current.mounted = true;
+    return () => {
+      current.current.mounted = false;
+      current.current.sequence += 1;
+    };
+  }, []);
+  const runAsync = useCallback(
+    async (...[input]) => {
+      current.current.sequence += 1;
+      const { sequence } = current.current;
+      const settings = callbacks.current;
+      const args = (
+        /* oxlint-disable typescript/no-unsafe-type-assertion -- InputArguments requires an I value unless I includes undefined; destructuring its conditional tuple loses that relationship. */
+        input
+      );
+      const isCurrent = () => current.current.mounted && current.current.identity === identity && current.current.sequence === sequence;
+      identity.state.set({ ...idleCall, status: "pending" });
+      let data;
+      try {
+        data = kind === "mutation" ? await store.client.mutate(
+          reference(name, "mutation"),
+          args
+        ) : await store.client.action(
+          reference(name, "action"),
+          args
+        );
+      } catch (error) {
+        const failure = appError(error);
+        if (isCurrent()) {
+          identity.state.set({
+            data: void 0,
+            error: failure,
+            status: "error"
+          });
+          settings.onError?.(failure, args);
+        }
+        store.onError(failure);
+        throw failure;
+      }
+      if (isCurrent()) {
+        identity.state.set({ data, error: null, status: "success" });
+        settings.onSuccess?.(data, args);
+      }
+      return data;
+    },
+    [identity, kind, store, name]
+  );
+  const run = useCallback(
+    (...args) => {
+      void (async () => {
+        try {
+          await runAsync(...args);
+        } catch {
+        }
+      })();
+    },
+    [runAsync]
+  );
+  const reset = useCallback(() => {
+    current.current.sequence += 1;
+    identity.state.set(idleCall);
+  }, [identity]);
+  return {
+    ...state,
+    isError: state.status === "error",
+    isPending: state.status === "pending",
+    isSuccess: state.status === "success",
+    reset,
+    run,
+    runAsync
+  };
+};
+var useMutation = (ref, options = {}) => {
+  const { run, runAsync, ...state } = useCall("mutation", ref, options);
+  return { ...state, mutate: run, mutateAsync: runAsync };
+};
+var useAction = (ref, options = {}) => {
+  const { run, runAsync, ...state } = useCall("action", ref, options);
+  return { ...state, execute: run, executeAsync: runAsync };
+};
+
+// src/routing.ts
+import { createContext as createContext3, h as h3, render } from "preact";
+import { useContext as useContext3 } from "preact/hooks";
+var isFunctionValue2 = (value) => typeof value === "function";
+var isObjectValue2 = (value) => typeof value === "object" && value !== null;
+var isStringValue = (value) => typeof value === "string";
+var defineRoute = (options) => {
+  if (!isFunctionValue2(options.shellComponent)) {
+    throw new TypeError("defineRoute requires a shellComponent.");
+  }
+  return Object.freeze({ shellComponent: options.shellComponent });
+};
+var Outlet = createContext3(void 0);
+var Route = () => {
+  const children = useContext3(Outlet);
+  if (children === void 0) {
+    throw new Error("Route must be rendered inside a root or layout.");
+  }
+  return children;
+};
+var Shell = ({
+  shell,
+  children
+}) => h3(Outlet.Provider, { value: children }, h3(shell, { children }));
+var shellComponent = (module, root) => {
+  const { definition } = module;
+  if (!root && isFunctionValue2(definition)) {
+    return definition;
+  }
+  if (isObjectValue2(definition) && "shellComponent" in definition && isFunctionValue2(definition.shellComponent)) {
+    return definition.shellComponent;
+  }
+  throw new TypeError(
+    `${module.filename} must default-export ${root ? "defineRoute({ shellComponent })" : "a layout component or defineRoute({ shellComponent })"}.`
+  );
+};
+var createFileClient = (options) => {
+  const rootShell = options.root ? shellComponent(options.root, true) : void 0;
+  const slotShells = new Map(
+    options.roots.map((root) => [root.slot, shellComponent(root, true)])
+  );
+  const layouts = options.layouts.map((layout) => ({
+    ...layout,
+    shell: shellComponent(layout, false)
+  }));
+  const definitions = {};
+  Object.setPrototypeOf(definitions, null);
+  for (const module of options.views) {
+    const view = (
+      /* oxlint-disable typescript/no-unsafe-type-assertion -- The generated module registry owns these component and view declarations; the runtime adapter preserves their exported implementations. */
+      module.definition
+    );
+    if (!view || !isFunctionValue2(view.component) || !isStringValue(view.path) || !view.path.startsWith("/")) {
+      throw new TypeError(
+        `${module.filename} must default-export defineView(...).`
+      );
+    }
+    if (view.slot !== module.slot) {
+      throw new Error(
+        `${module.filename} declares slot "${view.slot}" but is in "${module.slot}".`
+      );
+    }
+    if (view.path !== module.path) {
+      throw new Error(
+        `${module.filename} declares view "${view.path}" but its file location requires "${module.path}".`
+      );
+    }
+    definitions[module.slot] ??= /* @__PURE__ */ Object.create(null);
+    const slot = definitions[module.slot];
+    if (slot === void 0) {
+      throw new Error("Missing initialized slot registry.");
+    }
+    if (Object.hasOwn(slot, view.path)) {
+      throw new Error(
+        `Duplicate view "${view.path}" in slot "${module.slot}" (${module.filename}).`
+      );
+    }
+    slot[view.path] = view;
+  }
+  const slots = {};
+  Object.setPrototypeOf(slots, null);
+  for (const [slot, views] of Object.entries(definitions)) {
+    const slotLayouts = layouts.filter((layout) => layout.slot === slot).toSorted(
+      (a, b) => a.path.split("/").filter(Boolean).length - b.path.split("/").filter(Boolean).length
+    );
+    const paths = /* @__PURE__ */ new Set();
+    for (const layout of slotLayouts) {
+      if (paths.has(layout.path)) {
+        throw new Error(`Duplicate layout "${layout.path}" in slot "${slot}".`);
+      }
+      paths.add(layout.path);
+    }
+    const SlotRoute = (props) => {
+      const view = views[props.view];
+      if (!view) {
+        return null;
+      }
+      let child = h3(
+        Outlet.Provider,
+        { value: null },
+        h3(view.component, props)
+      );
+      const matching = slotLayouts.filter(
+        (layout) => layout.path === "/" || props.view === layout.path || props.view.startsWith(`${layout.path}/`)
+      );
+      for (const layout of matching.toReversed()) {
+        child = h3(Shell, {
+          children: child,
+          key: layout.path,
+          shell: layout.shell
+        });
+      }
+      const shell = slotShells.get(slot);
+      return shell ? h3(Shell, { children: child, shell }) : child;
+    };
+    slots[slot] = Object.fromEntries(
+      Object.entries(views).map(([path, view]) => [
+        path,
+        { ...view, component: SlotRoute }
+      ])
+    );
+  }
+  const Root = rootShell ? ({ children }) => h3(Shell, { children, shell: rootShell }) : void 0;
+  return {
+    $meta: { preactVersion: "11.0.1" },
+    $runtime: {
+      h: h3,
+      render: (vnode, parent) => {
+        render(vnode && Root ? h3(Root, { children: vnode }) : vnode, parent);
+      }
+    },
+    slots
+  };
+};
+
+// src/client/tools.ts
+import * as v from "valibot";
+var executeServerTool = async (session, path, input, request = globalThis.fetch, signal) => {
+  const response = await request(session.url, {
+    body: JSON.stringify({ input, path, requestId: crypto.randomUUID() }),
+    credentials: "omit",
+    headers: {
+      authorization: `Bearer ${session.token}`,
+      "content-type": "application/json"
+    },
+    method: "POST",
+    redirect: "error",
+    signal
+  });
+  if (!response.ok) {
+    throw new AppError(
+      (() => {
+        if (response.status === 401) {
+          return "UNAUTHORIZED";
+        }
+        if (response.status === 400) {
+          return "BAD_REQUEST";
+        }
+        return "UNAVAILABLE";
+      })(),
+      "Tool call failed"
+    );
+  }
+  return v.parse(
+    v.object({ output: v.optional(v.unknown()) }),
+    await response.json()
+  ).output;
+};
+var callTool = async (kind, path, input) => {
+  const bridge = globalThis.__tailorkitTools;
+  if (!bridge) {
+    throw new AppError("UNAVAILABLE", "Tool bridge unavailable");
+  }
+  if (kind === "client") {
+    return await bridge.client(path, input);
+  }
+  return await bridge.session(path).then(async (session) => await executeServerTool(session, path, input));
+};
+
+export {
+  defineView,
+  createRemoteComponent,
+  ClientProvider,
+  useQuery,
+  useMutation,
+  useAction,
+  defineRoute,
+  Route,
+  createFileClient,
+  callTool
+};

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 { StandardSchemaV1 } from "@standard-schema/spec";
+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 StandardSchemaV1;
+        handler: (...args: never[]) => infer _Output;
+    } ? Reference<K, StandardSchemaV1.InferInput<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>;