@highstate/designer 0.7.0 → 0.7.1

package/.output/server/node_modules/@trpc/server/dist/adapters/fetch/fetchRequestHandler.mjs

@@ -0,0 +1,74 @@
+import { resolveResponse } from '../../unstable-core-do-not-import/http/resolveResponse.mjs';
+import '../../unstable-core-do-not-import/rootConfig.mjs';
+import '../../vendor/unpromise/unpromise.mjs';
+import '../../unstable-core-do-not-import/stream/utils/disposable.mjs';
+
+/**
+ * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
+ *
+ * @example
+ * ```ts
+ * import type { AnyTRPCRouter } from '@trpc/server'
+ * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
+ * ```
+ */ // @trpc/server
+const trimSlashes = (path)=>{
+    path = path.startsWith('/') ? path.slice(1) : path;
+    path = path.endsWith('/') ? path.slice(0, -1) : path;
+    return path;
+};
+async function fetchRequestHandler(opts) {
+    const resHeaders = new Headers();
+    const createContext = async (innerOpts)=>{
+        return opts.createContext?.({
+            req: opts.req,
+            resHeaders,
+            ...innerOpts
+        });
+    };
+    const url = new URL(opts.req.url);
+    const pathname = trimSlashes(url.pathname);
+    const endpoint = trimSlashes(opts.endpoint);
+    const path = trimSlashes(pathname.slice(endpoint.length));
+    return await resolveResponse({
+        ...opts,
+        req: opts.req,
+        createContext,
+        path,
+        error: null,
+        onError (o) {
+            opts?.onError?.({
+                ...o,
+                req: opts.req
+            });
+        },
+        responseMeta (data) {
+            const meta = opts.responseMeta?.(data);
+            if (meta?.headers) {
+                if (meta.headers instanceof Headers) {
+                    for (const [key, value] of meta.headers.entries()){
+                        resHeaders.append(key, value);
+                    }
+                } else {
+                    /**
+           * @deprecated, delete in v12
+           */ for (const [key, value] of Object.entries(meta.headers)){
+                        if (Array.isArray(value)) {
+                            for (const v of value){
+                                resHeaders.append(key, v);
+                            }
+                        } else if (typeof value === 'string') {
+                            resHeaders.set(key, value);
+                        }
+                    }
+                }
+            }
+            return {
+                headers: resHeaders,
+                status: meta?.status
+            };
+        }
+    });
+}
+
+export { fetchRequestHandler };

package/.output/server/node_modules/@trpc/server/dist/adapters/fetch/index.mjs

@@ -0,0 +1 @@
+export { fetchRequestHandler } from './fetchRequestHandler.mjs';

package/.output/server/node_modules/@trpc/server/dist/adapters/node-http/incomingMessageToRequest.mjs

@@ -0,0 +1,119 @@
+import { TRPCError } from '../../unstable-core-do-not-import/error/TRPCError.mjs';
+import '../../vendor/unpromise/unpromise.mjs';
+import '../../unstable-core-do-not-import/stream/utils/disposable.mjs';
+import '../../unstable-core-do-not-import/rootConfig.mjs';
+
+function createBody(req, opts) {
+    // Some adapters will pre-parse the body and add it to the request object
+    if ('body' in req) {
+        if (req.body === undefined) {
+            // If body property exists but is undefined, return undefined
+            return undefined;
+        }
+        // If the body is already a string, return it directly
+        if (typeof req.body === 'string') {
+            return req.body;
+        }
+        // If body exists but isn't a string, stringify it as JSON
+        return JSON.stringify(req.body);
+    }
+    let size = 0;
+    let hasClosed = false;
+    return new ReadableStream({
+        start (controller) {
+            const onData = (chunk)=>{
+                size += chunk.length;
+                if (!opts.maxBodySize || size <= opts.maxBodySize) {
+                    controller.enqueue(new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength));
+                    return;
+                }
+                controller.error(new TRPCError({
+                    code: 'PAYLOAD_TOO_LARGE'
+                }));
+                hasClosed = true;
+                req.off('data', onData);
+                req.off('end', onEnd);
+            };
+            const onEnd = ()=>{
+                if (hasClosed) {
+                    return;
+                }
+                hasClosed = true;
+                req.off('data', onData);
+                req.off('end', onEnd);
+                controller.close();
+            };
+            req.on('data', onData);
+            req.on('end', onEnd);
+        },
+        cancel () {
+            req.destroy();
+        }
+    });
+}
+function createURL(req) {
+    try {
+        const protocol = // http2
+        req.headers[':scheme'] && req.headers[':scheme'] === 'https' || // http1
+        req.socket && 'encrypted' in req.socket && req.socket.encrypted ? 'https:' : 'http:';
+        const host = req.headers.host ?? req.headers[':authority'] ?? 'localhost';
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return new URL(req.url, `${protocol}//${host}`);
+    } catch (cause) {
+        throw new TRPCError({
+            code: 'BAD_REQUEST',
+            message: 'Invalid URL',
+            cause
+        });
+    }
+}
+function createHeaders(incoming) {
+    const headers = new Headers();
+    for(const key in incoming){
+        const value = incoming[key];
+        if (typeof key === 'string' && key.startsWith(':')) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value){
+                headers.append(key, item);
+            }
+        } else if (value != null) {
+            headers.append(key, value);
+        }
+    }
+    return headers;
+}
+/**
+ * Convert an [`IncomingMessage`](https://nodejs.org/api/http.html#class-httpincomingmessage) to a [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request)
+ */ function incomingMessageToRequest(req, res, opts) {
+    const ac = new AbortController();
+    const onAbort = ()=>{
+        res.off('close', onAbort);
+        req.socket?.off?.('close', onAbort);
+        // abort the request
+        ac.abort();
+    };
+    res.once('close', onAbort);
+    req.socket?.once?.('close', onAbort);
+    // Get host from either regular header or HTTP/2 pseudo-header
+    const url = createURL(req);
+    const init = {
+        headers: createHeaders(req.headers),
+        method: req.method,
+        signal: ac.signal
+    };
+    if (req.method !== 'GET' && req.method !== 'HEAD') {
+        init.body = createBody(req, opts);
+        // init.duplex = 'half' must be set when body is a ReadableStream, and Node follows the spec.
+        // However, this property is not defined in the TypeScript types for RequestInit, so we have
+        // to cast it here in order to set it without a type error.
+        // See https://fetch.spec.whatwg.org/#dom-requestinit-duplex
+        // @ts-expect-error this is fine
+        init.duplex = 'half';
+    }
+    const request = new Request(url, init);
+    return request;
+}
+
+export { createURL, incomingMessageToRequest };

package/.output/server/node_modules/@trpc/server/dist/adapters/node-http/index.mjs

@@ -0,0 +1,2 @@
+export { internal_exceptionHandler, nodeHTTPRequestHandler } from './nodeHTTPRequestHandler.mjs';
+export { createURL, incomingMessageToRequest } from './incomingMessageToRequest.mjs';

package/.output/server/node_modules/@trpc/server/dist/adapters/node-http/nodeHTTPRequestHandler.mjs

@@ -0,0 +1,92 @@
+import { getErrorShape } from '../../unstable-core-do-not-import/error/getErrorShape.mjs';
+import { getTRPCErrorFromUnknown } from '../../unstable-core-do-not-import/error/TRPCError.mjs';
+import { transformTRPCResponse } from '../../unstable-core-do-not-import/transformer.mjs';
+import { run } from '../../unstable-core-do-not-import/utils.mjs';
+import { resolveResponse } from '../../unstable-core-do-not-import/http/resolveResponse.mjs';
+import '../../unstable-core-do-not-import/rootConfig.mjs';
+import '../../vendor/unpromise/unpromise.mjs';
+import '../../unstable-core-do-not-import/stream/utils/disposable.mjs';
+import { incomingMessageToRequest } from './incomingMessageToRequest.mjs';
+import { writeResponse } from './writeResponse.mjs';
+
+/**
+ * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
+ *
+ * @example
+ * ```ts
+ * import type { AnyTRPCRouter } from '@trpc/server'
+ * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
+ * ```
+ */ // @trpc/server
+/**
+ * @internal
+ */ function internal_exceptionHandler(opts) {
+    return (cause)=>{
+        const { res, req } = opts;
+        const error = getTRPCErrorFromUnknown(cause);
+        const shape = getErrorShape({
+            config: opts.router._def._config,
+            error,
+            type: 'unknown',
+            path: undefined,
+            input: undefined,
+            ctx: undefined
+        });
+        opts.onError?.({
+            req,
+            error,
+            type: 'unknown',
+            path: undefined,
+            input: undefined,
+            ctx: undefined
+        });
+        const transformed = transformTRPCResponse(opts.router._def._config, {
+            error: shape
+        });
+        res.statusCode = shape.data.httpStatus;
+        res.end(JSON.stringify(transformed));
+    };
+}
+/**
+ * @remark the promise never rejects
+ */ async function nodeHTTPRequestHandler(opts) {
+    return new Promise((resolve)=>{
+        const handleViaMiddleware = opts.middleware ?? ((_req, _res, next)=>next());
+        opts.res.once('finish', ()=>{
+            resolve();
+        });
+        return handleViaMiddleware(opts.req, opts.res, (err)=>{
+            run(async ()=>{
+                const request = incomingMessageToRequest(opts.req, opts.res, {
+                    maxBodySize: opts.maxBodySize ?? null
+                });
+                // Build tRPC dependencies
+                const createContext = async (innerOpts)=>{
+                    return await opts.createContext?.({
+                        ...opts,
+                        ...innerOpts
+                    });
+                };
+                const response = await resolveResponse({
+                    ...opts,
+                    req: request,
+                    error: err ? getTRPCErrorFromUnknown(err) : null,
+                    createContext,
+                    onError (o) {
+                        opts?.onError?.({
+                            ...o,
+                            req: opts.req
+                        });
+                    }
+                });
+                await writeResponse({
+                    request,
+                    response,
+                    rawResponse: opts.res
+                });
+            }).catch(internal_exceptionHandler(opts));
+        });
+    });
+}
+
+export { internal_exceptionHandler, nodeHTTPRequestHandler };

package/.output/server/node_modules/@trpc/server/dist/adapters/node-http/writeResponse.mjs

@@ -0,0 +1,79 @@
+import { isAbortError } from '../../unstable-core-do-not-import/http/abortError.mjs';
+import '../../vendor/unpromise/unpromise.mjs';
+import '../../unstable-core-do-not-import/stream/utils/disposable.mjs';
+import '../../unstable-core-do-not-import/rootConfig.mjs';
+
+// eslint-disable-next-line no-restricted-imports
+async function writeResponseBodyChunk(res, chunk) {
+    // useful for debugging 🙃
+    // console.debug('writing', new TextDecoder().decode(chunk));
+    if (res.write(chunk) === false) {
+        await new Promise((resolve, reject)=>{
+            const onError = (err)=>{
+                reject(err);
+                cleanup();
+            };
+            const onDrain = ()=>{
+                resolve();
+                cleanup();
+            };
+            const cleanup = ()=>{
+                res.off('error', onError);
+                res.off('drain', onDrain);
+            };
+            res.once('error', onError);
+            res.once('drain', onDrain);
+        });
+    }
+}
+/**
+ * @internal
+ */ async function writeResponseBody(opts) {
+    const { res } = opts;
+    try {
+        const writableStream = new WritableStream({
+            async write (chunk) {
+                await writeResponseBodyChunk(res, chunk);
+                res.flush?.();
+            }
+        });
+        await opts.body.pipeTo(writableStream, {
+            signal: opts.signal
+        });
+    } catch (err) {
+        if (isAbortError(err)) {
+            return;
+        }
+        throw err;
+    }
+}
+/**
+ * @internal
+ */ async function writeResponse(opts) {
+    const { response, rawResponse } = opts;
+    // Only override status code if it hasn't been explicitly set in a procedure etc
+    if (rawResponse.statusCode === 200) {
+        rawResponse.statusCode = response.status;
+    }
+    for (const [key, value] of response.headers){
+        rawResponse.setHeader(key, value);
+    }
+    try {
+        if (response.body) {
+            await writeResponseBody({
+                res: rawResponse,
+                signal: opts.request.signal,
+                body: response.body
+            });
+        }
+    } catch (err) {
+        if (!rawResponse.headersSent) {
+            rawResponse.statusCode = 500;
+        }
+        throw err;
+    } finally{
+        rawResponse.end();
+    }
+}
+
+export { writeResponse, writeResponseBody };

package/.output/server/node_modules/@trpc/server/dist/index.mjs

@@ -1,7 +1,7 @@
 export { createFlatProxy as createTRPCFlatProxy, createRecursiveProxy as createTRPCRecursiveProxy } from './unstable-core-do-not-import/createProxy.mjs';
 export { getErrorShape } from './unstable-core-do-not-import/error/getErrorShape.mjs';
 export { TRPCError, getTRPCErrorFromUnknown } from './unstable-core-do-not-import/error/TRPCError.mjs';
-export { callProcedure as callTRPCProcedure, lazy as experimental_lazy } from './unstable-core-do-not-import/router.mjs';
+export { callProcedure as callTRPCProcedure, lazy as experimental_lazy, lazy } from './unstable-core-do-not-import/router.mjs';
 import './vendor/unpromise/unpromise.mjs';
 import './unstable-core-do-not-import/stream/utils/disposable.mjs';
 export { isTrackedEnvelope, sse, tracked } from './unstable-core-do-not-import/stream/tracked.mjs';

package/.output/server/node_modules/@trpc/server/dist/unstable-core-do-not-import/middleware.mjs

@@ -29,7 +29,7 @@ import { isObject } from './utils.mjs';
 /**
  * Create a standalone middleware
  * @see https://trpc.io/docs/v11/server/middlewares#experimental-standalone-middlewares
- * @deprecated use `.unstable_concat()` instead
+ * @deprecated use `.concat()` instead
  */ const experimental_standaloneMiddleware = ()=>({
         create: createMiddlewareFactory()
     });

package/.output/server/node_modules/@trpc/server/dist/unstable-core-do-not-import/parser.mjs

@@ -2,13 +2,14 @@ import { StandardSchemaV1Error } from '../vendor/standard-schema-v1/error.mjs';
 
 function getParseFn(procedureParser) {
     const parser = procedureParser;
+    const isStandardSchema = '~standard' in parser;
     if (typeof parser === 'function' && typeof parser.assert === 'function') {
         // ParserArkTypeEsque - arktype schemas shouldn't be called as a function because they return a union type instead of throwing
         return parser.assert.bind(parser);
     }
-    if (typeof parser === 'function') {
+    if (typeof parser === 'function' && !isStandardSchema) {
         // ParserValibotEsque (>= v0.31.0)
-        // ParserCustomValidatorEsque
+        // ParserCustomValidatorEsque - note the check for standard-schema conformance - some libraries like `effect` use function schemas which are *not* a "parse" function.
         return parser;
     }
     if (typeof parser.parseAsync === 'function') {
@@ -35,7 +36,7 @@ function getParseFn(procedureParser) {
             return value;
         };
     }
-    if ('~standard' in parser) {
+    if (isStandardSchema) {
         // StandardSchemaEsque
         return async (value)=>{
             const result = await parser['~standard'].validate(value);

package/.output/server/node_modules/@trpc/server/dist/unstable-core-do-not-import/procedureBuilder.mjs

@@ -68,6 +68,9 @@ function createBuilder(initDef = {}) {
         unstable_concat (builder) {
             return createNewBuilder(_def, builder._def);
         },
+        concat (builder) {
+            return createNewBuilder(_def, builder._def);
+        },
         query (resolver) {
             return createResolver({
                 ..._def,

package/.output/server/node_modules/@trpc/server/dist/unstable-core-do-not-import/router.mjs

@@ -27,7 +27,7 @@ function once(fn) {
         }
         const routers = Object.values(mod);
         if (routers.length !== 1 || !isRouter(routers[0])) {
-            throw new Error("Invalid router module - either define exactly 1 export or return the router directly.\nExample: `experimental_lazy(() => import('./slow.js').then((m) => m.slowRouter))`");
+            throw new Error("Invalid router module - either define exactly 1 export or return the router directly.\nExample: `lazy(() => import('./slow.js').then((m) => m.slowRouter))`");
         }
         return routers[0];
     }

package/.output/server/node_modules/@trpc/server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/server",
-  "version": "11.0.0-rc.808+4df1eb8fa",
+  "version": "11.0.1",
   "description": "The tRPC server library",
   "author": "KATT",
   "license": "MIT",
@@ -118,7 +118,7 @@
   },
   "devDependencies": {
     "@fastify/websocket": "^10.0.1",
-    "@tanstack/react-query": "^5.66.0",
+    "@tanstack/react-query": "^5.67.1",
     "@types/aws-lambda": "^8.10.137",
     "@types/express": "^5.0.0",
     "@types/hash-sum": "^1.0.0",
@@ -133,15 +133,15 @@
     "fastify-plugin": "^5.0.0",
     "hash-sum": "^2.0.0",
     "myzod": "^1.3.1",
-    "next": "^15.1.3",
+    "next": "^15.1.7",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
     "rollup": "^4.34.8",
     "superjson": "^1.12.4",
     "superstruct": "^2.0.0",
     "tsx": "^4.19.3",
-    "typescript": "^5.7.2",
-    "valibot": "1.0.0-rc.1",
+    "typescript": "^5.8.2",
+    "valibot": "1.0.0",
     "ws": "^8.0.0",
     "yup": "^1.0.0",
     "zod": "^3.24.2"
@@ -152,5 +152,5 @@
   "peerDependencies": {
     "typescript": ">=5.7.2"
   },
-  "gitHead": "4df1eb8fa820341db81bc7cb9907f30dfebbf4d7"
+  "gitHead": "662da0bb0a2766125e3f7eced3576f05a850a069"
 }

package/.output/server/node_modules/unhead/dist/plugins.mjs

@@ -0,0 +1,94 @@
+export { A as AliasSortingPlugin, D as DeprecationsPlugin, P as PromisesPlugin, T as TemplateParamsPlugin } from './shared/unhead.DeCxexjU.mjs';
+import { d as defineHeadPlugin } from './shared/unhead.CApf5sj3.mjs';
+export { F as FlatMetaPlugin, S as SafeInputPlugin } from './shared/unhead.CApf5sj3.mjs';
+import './shared/unhead.DZbvapt-.mjs';
+import './shared/unhead.C13swrCa.mjs';
+import './shared/unhead.DQc16pHI.mjs';
+import './shared/unhead.yem5I2v_.mjs';
+
+function CanonicalPlugin(options) {
+  return (head) => {
+    function resolvePath(path) {
+      if (options?.customResolver) {
+        return options.customResolver(path);
+      }
+      let host = options.canonicalHost || (!head.ssr ? window.location.origin : "");
+      if (!host.startsWith("http") && !host.startsWith("//")) {
+        host = `https://${host}`;
+      }
+      host = new URL(host).origin;
+      if (path.startsWith("http") || path.startsWith("//"))
+        return path;
+      try {
+        return new URL(path, host).toString();
+      } catch {
+        return path;
+      }
+    }
+    return {
+      key: "canonical",
+      hooks: {
+        "tags:resolve": (ctx) => {
+          for (const tag of ctx.tags) {
+            if (tag.tag === "meta") {
+              if (tag.props.property?.startsWith("og:image") || tag.props.name?.startsWith("twitter:image")) {
+                tag.props.content = resolvePath(tag.props.content);
+              } else if (tag.props?.property === "og:url") {
+                tag.props.content = resolvePath(tag.props.content);
+              }
+            } else if (tag.tag === "link" && tag.props.rel === "canonical") {
+              tag.props.href = resolvePath(tag.props.href);
+            }
+          }
+        }
+      }
+    };
+  };
+}
+
+function InferSeoMetaPlugin(options = {}) {
+  return defineHeadPlugin((head) => {
+    head.push({
+      meta: [
+        {
+          name: "twitter:card",
+          content: options.twitterCard || "summary_large_image",
+          tagPriority: "low"
+        },
+        {
+          "property": "og:title",
+          "tagPriority": "low",
+          "data-infer": ""
+        },
+        {
+          "property": "og:description",
+          "tagPriority": "low",
+          "data-infer": ""
+        }
+      ]
+    });
+    return {
+      key: "infer-seo-meta",
+      hooks: {
+        "tags:beforeResolve": ({ tagMap }) => {
+          let title = head._title || "";
+          const titleTemplate = head._titleTemplate;
+          const ogTitle = tagMap.get("meta:og:title");
+          if (typeof ogTitle?.props["data-infer"] !== "undefined") {
+            if (titleTemplate) {
+              title = typeof titleTemplate === "function" ? titleTemplate(title) : titleTemplate.replace("%s", title);
+            }
+            ogTitle.props.content = options.ogTitle ? options.ogTitle(title) : title || "";
+          }
+          const description = tagMap.get("meta:description")?.props?.content;
+          const ogDescription = tagMap.get("meta:og:description");
+          if (typeof ogDescription?.props["data-infer"] !== "undefined") {
+            ogDescription.props.content = options.ogDescription ? options.ogDescription(description) : description || "";
+          }
+        }
+      }
+    };
+  });
+}
+
+export { CanonicalPlugin, InferSeoMetaPlugin, defineHeadPlugin };