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

package/dist/{chunk-STTKSRAI.js → chunk-UDXPIO6D.js}

@@ -1,15 +1,16 @@
 import {
   createClient,
   reference
-} from "./chunk-SWBQZDWT.js";
+} from "./chunk-PJBDA2RU.js";
 import {
   AppError,
   appError
-} from "./chunk-IJBQ77AH.js";
+} 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(
@@ -17,12 +18,15 @@ function defineView(options) {
     );
   }
   const path = options.view;
-  const Context2 = createContext(
-    null
+  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
   );
-  const instances = options.instances;
-  if (instances && !instances.resolver) {
-    throw new Error("View instance resolvers must be compiled with the TailorKit app build.");
+  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") {
@@ -35,34 +39,59 @@ function defineView(options) {
     }
     return h(
       Context2.Provider,
-      { value: { context: props.context, instance: props.instance } },
-      h(options.component, { key: props.instance?.key })
+      {
+        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,
-    ...instances?.resolver ? { instances: { resolver: instances.resolver } } : {},
     useContext: () => {
       const context = useContext(Context2);
       if (context === null) {
-        throw new Error(`View context is only available while rendering "${path}".`);
+        throw new Error(
+          `View context is only available while rendering "${path}".`
+        );
       }
       return context.context;
     },
     useInstance: () => {
       const value = useContext(Context2);
-      if (!value?.instance)
+      if (!value?.instance) {
         throw new Error(
           `View instance is only available while rendering an instance of "${path}".`
         );
-      return value.instance;
+      }
+      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(/([a-z0-9])([A-Z])/gu, "$1-$2").replaceAll(/[\s_]+/gu, "-").toLowerCase()}`;
+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 = {}) => {
@@ -72,45 +101,66 @@ var createRemoteComponent = (name, options = {}) => {
     const nextProps = { ...props };
     const callbackMap = {};
     for (const [key, inputCount] of Object.entries(callbacks)) {
-      const callback = nextProps[key];
+      const operation = nextProps[key];
       Reflect.deleteProperty(nextProps, key);
-      if (typeof callback !== "function") {
+      if (!isFunctionValue(operation)) {
         continue;
       }
       const eventName = toCallbackEventName(key);
       callbackMap[eventName] = { callback: key, inputCount };
       nextProps[toEventProp(eventName)] = (event) => {
-        callback(...(event.detail ?? []).slice(0, inputCount));
+        operation(...(event.detail ?? []).slice(0, inputCount));
       };
     }
     const serializedProps = Object.fromEntries(
-      Object.entries(nextProps).filter(([, value]) => typeof value !== "function")
+      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 ? children : void 0);
+    return h(
+      tagName,
+      nextProps,
+      options.children === true ? children : void 0
+    );
   };
 };
 
 // src/preact.ts
-import { atom as atom2, computed } from "nanostores";
 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";
+import {
+  useCallback,
+  useContext as useContext2,
+  useEffect,
+  useLayoutEffect,
+  useMemo,
+  useRef
+} from "preact/hooks";
 
 // src/client/query-store.ts
 import { atom } from "nanostores";
-var pendingQuery = { data: void 0, error: null, status: "pending" };
-function serializeInput(input) {
-  return JSON.stringify({ input, defined: input !== void 0 }, (_key, value) => {
-    if (value && typeof value === "object" && !Array.isArray(value)) {
-      return Object.fromEntries(Object.entries(value).toSorted(([a], [b]) => a.localeCompare(b)));
+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();
@@ -143,14 +193,24 @@ var QueryStore = class {
         if (this.disposed || this.entries.get(key) !== current) {
           return;
         }
-        publish({ data: this.state.get().get(key)?.data, error, status: "error" });
+        publish({
+          data: (
+            /* oxlint-disable typescript/no-unsafe-type-assertion -- The entry is created and updated by this query reference's typed subscription; the shared cache erases its output generic. */
+            this.state.get().get(key)?.data
+          ),
+          /* oxlint-enable typescript/no-unsafe-type-assertion */
+          error,
+          status: "error"
+        });
         this.onError(error);
       };
       try {
         current.stop = this.client.subscribe(
           ref,
           input,
-          (data) => publish({ data, error: null, status: "success" }),
+          (data) => {
+            publish({ data, error: null, status: "success" });
+          },
           { onError }
         );
       } catch (error) {
@@ -195,69 +255,100 @@ var QueryStore = class {
 
 // src/preact.ts
 var Context = createContext2(null);
-function ClientProvider({ children, client, onError }) {
+var ClientProvider = ({
+  children,
+  client,
+  onError
+}) => {
   const errorHandler = useRef(onError);
   errorHandler.current = onError;
   const store = useMemo(
-    () => new QueryStore(client ?? createClient(), !client, (error) => errorHandler.current?.(error)),
+    () => new QueryStore(
+      client ?? createClient(),
+      !client,
+      (error) => errorHandler.current?.(error)
+    ),
     [client]
   );
-  useLayoutEffect(() => () => store.dispose(), [store]);
+  useLayoutEffect(
+    () => () => {
+      store.dispose();
+    },
+    [store]
+  );
   return h2(Context.Provider, { value: store }, children);
-}
-function useQueryStore() {
+};
+var useQueryStore = () => {
   const store = useContext2(Context);
   if (!store) {
-    throw new Error("TailorKit backend hooks require a ClientProvider at the app root.");
+    throw new Error(
+      "TailorKit backend hooks require a ClientProvider at the app root."
+    );
   }
   return store;
-}
-function useQuery(ref, ...[input, options]) {
+};
+var useQuery = (ref, ...[input, options]) => {
   const store = useQueryStore();
   const enabled = options?.enabled ?? true;
-  const name = ref.name;
+  const { name } = ref;
   const serialized = serializeInput(input);
   const key = `${name}\0${serialized}`;
-  const stableInput = useMemo(() => JSON.parse(serialized).input, [serialized]);
-  const stableReference = useMemo(() => reference(name, "query"), [name]);
+  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) => enabled ? queries.get(key) ?? pendingQuery : pendingQuery
+      (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(() => {
-    if (enabled) {
-      return store.watch(key, stableReference, stableInput);
-    }
-  }, [store, key, enabled, stableInput, stableReference]);
+  useEffect(
+    () => enabled ? store.watch(key, stableReference, stableInput) : void 0,
+    [store, key, enabled, stableInput, stableReference]
+  );
   return {
     ...state,
-    isPending: state.status === "pending",
+    isError: state.status === "error",
     isLoading: enabled && state.status === "pending",
-    isSuccess: state.status === "success",
-    isError: state.status === "error"
+    isPending: state.status === "pending",
+    isSuccess: state.status === "success"
   };
-}
+};
 var idleCall = { data: void 0, error: null, status: "idle" };
-function useCall(kind, ref, options) {
+var useCall = (kind, ref, options) => {
   const store = useQueryStore();
-  const name = ref.name;
+  const { name } = ref;
   const identity = useMemo(
     () => ({
-      store,
-      name,
       kind,
-      state: atom2(idleCall)
+      name,
+      state: atom2(idleCall),
+      store
     }),
     [store, name, kind]
   );
   const state = useStore(identity.state);
-  const current = useRef({ identity, sequence: 0, mounted: true });
+  const current = useRef({ identity, mounted: true, sequence: 0 });
   if (current.current.identity !== identity) {
-    current.current = { identity, sequence: current.current.sequence + 1, mounted: true };
+    current.current = {
+      identity,
+      mounted: true,
+      sequence: current.current.sequence + 1
+    };
   }
   const callbacks = useRef(options);
   callbacks.current = options;
@@ -270,18 +361,32 @@ function useCall(kind, ref, options) {
   }, []);
   const runAsync = useCallback(
     async (...[input]) => {
-      const sequence = ++current.current.sequence;
+      current.current.sequence += 1;
+      const { sequence } = current.current;
       const settings = callbacks.current;
-      const args = input;
+      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);
+        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" });
+          identity.state.set({
+            data: void 0,
+            error: failure,
+            status: "error"
+          });
           settings.onError?.(failure, args);
         }
         store.onError(failure);
@@ -297,8 +402,13 @@ function useCall(kind, ref, options) {
   );
   const run = useCallback(
     (...args) => {
-      void runAsync(...args).catch(() => {
-      });
+      void (async () => {
+        try {
+          return await runAsync(...args);
+        } catch {
+        }
+        return void 0;
+      })();
     },
     [runAsync]
   );
@@ -308,74 +418,89 @@ function useCall(kind, ref, options) {
   }, [identity]);
   return {
     ...state,
+    isError: state.status === "error",
     isPending: state.status === "pending",
     isSuccess: state.status === "success",
-    isError: state.status === "error",
     reset,
     run,
     runAsync
   };
-}
-function useMutation(ref, options = {}) {
+};
+var useMutation = (ref, options = {}) => {
   const { run, runAsync, ...state } = useCall("mutation", ref, options);
   return { ...state, mutate: run, mutateAsync: runAsync };
-}
-function useAction(ref, options = {}) {
+};
+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";
-function defineRoute(options) {
-  if (typeof options.shellComponent !== "function") {
+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);
-function Route() {
+var Route = () => {
   const children = useContext3(Outlet);
   if (children === void 0) {
     throw new Error("Route must be rendered inside a root or layout.");
   }
   return children;
-}
-function Shell({ shell, children }) {
-  return h3(Outlet.Provider, { value: children }, h3(shell, { children }));
-}
-function shellComponent(module, root) {
-  const definition = module.definition;
-  if (!root && typeof definition === "function") {
+};
+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 (definition && typeof definition === "object" && "shellComponent" in definition && typeof definition.shellComponent === "function") {
+  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 })"}.`
   );
-}
-function createFileClient(options) {
+};
+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 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 = /* @__PURE__ */ Object.create(null);
   for (const module of options.views) {
-    const view = module.definition;
-    if (!view || typeof view.component !== "function" || typeof view.path !== "string" || !view.path.startsWith("/")) {
-      throw new TypeError(`${module.filename} must default-export defineView(...).`);
+    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}".`
       );
     }
-    const slot = definitions[module.slot] ??= /* @__PURE__ */ Object.create(null);
+    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}).`
@@ -400,54 +525,84 @@ function createFileClient(options) {
       if (!view) {
         return null;
       }
-      let child = h3(Outlet.Provider, { value: null }, h3(view.component, props));
+      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, { key: layout.path, shell: layout.shell, children: child });
+        child = h3(Shell, {
+          children: child,
+          key: layout.path,
+          shell: layout.shell
+        });
       }
       const shell = slotShells.get(slot);
-      return shell ? h3(Shell, { shell, children: child }) : child;
+      return shell ? h3(Shell, { children: child, shell }) : child;
     };
     slots[slot] = Object.fromEntries(
-      Object.entries(views).map(([path, view]) => [path, { ...view, component: SlotRoute }])
+      Object.entries(views).map(([path, view]) => [
+        path,
+        { ...view, component: SlotRoute }
+      ])
     );
   }
-  const Root = rootShell ? ({ children }) => h3(Shell, { shell: rootShell, children }) : void 0;
+  const Root = rootShell ? ({ children }) => h3(Shell, { children, shell: rootShell }) : void 0;
   return {
-    $meta: { preactVersion: "11.0.0" },
+    $meta: { preactVersion: "11.0.1" },
     $runtime: {
       h: h3,
-      render: (vnode, parent) => render(vnode && Root ? h3(Root, { children: vnode }) : vnode, parent)
+      render: (vnode, parent) => {
+        render(vnode && Root ? h3(Root, { children: vnode }) : vnode, parent);
+      }
     },
     slots
   };
-}
+};
 
 // src/client/tools.ts
-function callTool(kind, path, input) {
-  const bridge = globalThis.__tailorkitTools;
-  if (!bridge) return Promise.reject(new AppError("UNAVAILABLE", "Tool bridge unavailable"));
-  if (kind === "client") return bridge.client(path, input);
-  return bridge.session(path).then((session) => executeServerTool(session, path, input));
-}
-async function executeServerTool(session, path, input, request = globalThis.fetch, signal) {
+import { z } from "zod";
+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",
-    credentials: "omit",
-    signal,
-    headers: { authorization: `Bearer ${session.token}`, "content-type": "application/json" },
-    body: JSON.stringify({ path, input, requestId: crypto.randomUUID() })
+    signal
   });
-  if (!response.ok)
+  if (!response.ok) {
     throw new AppError(
-      response.status === 401 ? "UNAUTHORIZED" : response.status === 400 ? "BAD_REQUEST" : "UNAVAILABLE",
+      (() => {
+        if (response.status === 401) {
+          return "UNAUTHORIZED";
+        }
+        if (response.status === 400) {
+          return "BAD_REQUEST";
+        }
+        return "UNAVAILABLE";
+      })(),
       "Tool call failed"
     );
-  return (await response.json()).output;
-}
+  }
+  return z.object({ output: z.unknown().optional() }).parse(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,