@tscircuit/cli 0.1.1494 → 0.1.1496

package/dist/cli/main.js

@@ -100763,7 +100763,7 @@ var import_perfect_cli = __toESM2(require_dist2(), 1);
 // lib/getVersion.ts
 import { createRequire as createRequire2 } from "node:module";
 // package.json
-var version = "0.1.1493";
+var version = "0.1.1495";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -100780,6 +100780,7 @@ var package_default = {
     "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#b6d5fe675adc26a2fc988aa081e6fb51e6bf696a",
     "@tscircuit/eval": "^0.0.915",
     "@tscircuit/fake-snippets": "^0.0.182",
+    "@tscircuit/fake-ul-kicad-proxy": "github:tscircuit/fake-ul-kicad-proxy#d174c33c1b17a52d7a9dc3c2b5506d6fd593bed7",
     "@tscircuit/file-server": "^0.0.32",
     "@tscircuit/image-utils": "^0.0.3",
     "@tscircuit/krt-wasm": "^0.1.0",
@@ -100787,6 +100788,7 @@ var package_default = {
     "@tscircuit/props": "^0.0.546",
     "@tscircuit/runframe": "^0.0.2074",
     "@tscircuit/schematic-match-adapt": "^0.0.22",
+    "@tscircuit/ti-parts-engine": "github:tscircuit/ti-parts-engine#cead194495b8fbfb73a88b5995ce86a4b61a9d04",
     "@tscircuit/solver-utils": "0.0.16",
     "@types/bun": "^1.2.2",
     "@types/configstore": "^6.0.2",
@@ -100824,7 +100826,7 @@ var package_default = {
     jszip: "^3.10.1",
     "jwt-decode": "^4.0.0",
     "kicad-component-converter": "^0.1.40",
-    "kicad-to-circuit-json": "^0.0.94",
+    "kicad-to-circuit-json": "^0.0.96",
     kicadts: "^0.0.45",
     kleur: "^4.1.5",
     ky: "^1.7.4",
@@ -100838,7 +100840,7 @@ var package_default = {
     semver: "^7.6.3",
     stepts: "^0.0.3",
     tempy: "^3.1.0",
-    tscircuit: "^0.0.1849-libonly",
+    tscircuit: "0.0.1885-libonly",
     tsx: "^4.7.1",
     "typed-ky": "^0.0.4",
     zod: "^3.23.8"
@@ -250235,9 +250237,6 @@ class WinterSpecMultiPartFormDataResponse extends WinterSpecResponse {
     return new Response(formData, this.options);
   }
 }
-function createWinterSpecRequest(request, options) {
-  return Object.assign(request, options);
-}
 function mergeHeaders2(h12, h22) {
   return new Headers(Object.fromEntries([
     ...h12 instanceof Headers ? h12 : new Headers(h12 ?? undefined).entries() ?? [],
@@ -250251,7 +250250,6 @@ var DEFAULT_CONTEXT = {
   multipartFormData: WinterSpecResponse.multipartFormData,
   custom: WinterSpecResponse.custom
 };
-var getDefaultContext = () => ({ ...DEFAULT_CONTEXT });
 
 // node_modules/winterspec/dist/serve/create-node-server-from-route-map.js
 var import_next_route_matcher = __toESM2(require_dist8(), 1);
@@ -250259,7 +250257,119 @@ var import_next_route_matcher = __toESM2(require_dist8(), 1);
 // node_modules/winterspec/dist/create-with-winter-spec.js
 import { z as z5 } from "zod";
 
-// node_modules/winterspec/dist/lib/format-zod-error.js
+// node_modules/winterspec/dist/middleware/with-input-validation.js
+import { z as z4, ZodError as ZodError2, ZodFirstPartyTypeKind as ZodFirstPartyTypeKind2 } from "zod";
+
+// node_modules/winterspec/dist/serve/create-winter-spec-from-route-map.js
+var import_next_route_matcher2 = __toESM2(require_dist8(), 1);
+
+// node_modules/winterspec/dist/adapters/node.js
+var EdgePrimitives = __toESM2(require_dist6(), 1);
+var getNodeHandler = (winterSpec, { port, middleware = [] }) => {
+  const transformToNode = transformToNodeBuilder({
+    defaultOrigin: `http://localhost${port ? `:${port}` : ""}`
+  });
+  return transformToNode((req) => winterSpec.makeRequest(req, {
+    middleware
+  }));
+};
+
+// node_modules/@tscircuit/file-server/dist/bundle.js
+var import_next_route_matcher4 = __toESM2(require_dist8(), 1);
+
+// node_modules/@tscircuit/file-server/node_modules/winterspec/dist/types/web-handler.js
+class WinterSpecResponse2 {
+  statusCode() {
+    return this.options.status ?? 200;
+  }
+  status(status) {
+    this.options.status = status;
+    return this;
+  }
+  header(key, value) {
+    this.options.headers = mergeHeaders3(this.options.headers, {
+      [key]: value
+    });
+    return this;
+  }
+  headers(headers) {
+    this.options.headers = mergeHeaders3(this.options.headers, headers);
+    return this;
+  }
+  statusText(statusText) {
+    this.options.statusText = statusText;
+    return this;
+  }
+  constructor(options = {}) {
+    this.options = options;
+  }
+  static json(...args) {
+    return new WinterSpecJsonResponse2(...args);
+  }
+  static multipartFormData(...args) {
+    return new WinterSpecMultiPartFormDataResponse2(...args);
+  }
+  static custom(...args) {
+    return new WinterSpecCustomResponse2(...args);
+  }
+}
+
+class WinterSpecJsonResponse2 extends WinterSpecResponse2 {
+  constructor(data, options = {}) {
+    super(options);
+    this.data = data;
+    this.options.headers = mergeHeaders3(this.options.headers, {
+      "Content-Type": "application/json"
+    });
+  }
+  serializeToResponse(schema) {
+    return new Response(JSON.stringify(schema.parse(this.data)), this.options);
+  }
+}
+
+class WinterSpecCustomResponse2 extends WinterSpecResponse2 {
+  constructor(data, contentType, options = {}) {
+    super(options);
+    this.data = data;
+    this.contentType = contentType;
+    this.options.headers = mergeHeaders3(this.options.headers, {
+      "Content-Type": contentType
+    });
+  }
+  serializeToResponse(schema) {
+    return new Response(schema.parse(this.data), this.options);
+  }
+}
+class WinterSpecMultiPartFormDataResponse2 extends WinterSpecResponse2 {
+  constructor(data, options = {}) {
+    super(options);
+    this.data = data;
+    this.options.headers = mergeHeaders3(this.options.headers, {
+      "Content-Type": "multipart/form-data"
+    });
+  }
+  serializeToResponse(schema) {
+    const formData = new FormData;
+    for (const [key, value] of Object.entries(schema.parse(this.data))) {
+      formData.append(key, value instanceof Blob ? value : String(value));
+    }
+    return new Response(formData, this.options);
+  }
+}
+function createWinterSpecRequest2(request, options) {
+  return Object.assign(request, options);
+}
+function mergeHeaders3(h12, h22) {
+  return new Headers(Object.fromEntries([
+    ...h12 instanceof Headers ? h12 : new Headers(h12 ?? undefined).entries() ?? [],
+    ...h22 instanceof Headers ? h22 : new Headers(h22 ?? undefined).entries() ?? []
+  ]));
+}
+
+// node_modules/@tscircuit/file-server/node_modules/winterspec/dist/create-with-winter-spec.js
+import { z as z7 } from "zod";
+
+// node_modules/@tscircuit/file-server/node_modules/winterspec/dist/lib/format-zod-error.js
 var zodIssueToString = (issue) => {
   if (issue.path.join(".") === "") {
     return issue.message;
@@ -250269,7 +250379,7 @@ var zodIssueToString = (issue) => {
   }
   return `${issue.message} for "${issue.path.join(".")}"`;
 };
-var formatZodError = (error) => {
+var formatZodError2 = (error) => {
   let message;
   if (error.issues.length === 1) {
     const issue = error.issues[0];
@@ -250285,7 +250395,7 @@ var formatZodError = (error) => {
   return message;
 };
 
-// node_modules/winterspec/dist/middleware/http-exceptions.js
+// node_modules/@tscircuit/file-server/node_modules/winterspec/dist/middleware/http-exceptions.js
 class WinterSpecMiddlewareError extends Error {
   constructor(message, status = 500) {
     super(message);
@@ -250296,79 +250406,79 @@ class WinterSpecMiddlewareError extends Error {
   }
 }
 
-class MethodNotAllowedError extends WinterSpecMiddlewareError {
+class MethodNotAllowedError2 extends WinterSpecMiddlewareError {
   constructor(allowedMethods) {
     super(`only ${allowedMethods.join(",")} accepted`, 405);
   }
 }
-class BadRequestError extends WinterSpecMiddlewareError {
+class BadRequestError2 extends WinterSpecMiddlewareError {
   constructor(message) {
     super(message, 400);
   }
 }
 
-class InvalidQueryParamsError extends BadRequestError {
+class InvalidQueryParamsError2 extends BadRequestError2 {
   constructor(message) {
     super(message);
   }
 }
 
-class InvalidContentTypeError extends BadRequestError {
+class InvalidContentTypeError2 extends BadRequestError2 {
   constructor(message) {
     super(message);
   }
 }
 
-class InputParsingError extends BadRequestError {
+class InputParsingError2 extends BadRequestError2 {
   constructor(message) {
     super(message);
   }
 }
 
-class InputValidationError extends BadRequestError {
+class InputValidationError2 extends BadRequestError2 {
   constructor(error) {
-    super(formatZodError(error));
+    super(formatZodError2(error));
   }
 }
 
-class ResponseValidationError extends WinterSpecMiddlewareError {
+class ResponseValidationError2 extends WinterSpecMiddlewareError {
   constructor(error) {
-    super(formatZodError(error), 500);
+    super(formatZodError2(error), 500);
   }
 }
 
-// node_modules/winterspec/dist/middleware/with-methods.js
-var withMethods = (methods) => (req, ctx, next) => {
+// node_modules/@tscircuit/file-server/node_modules/winterspec/dist/middleware/with-methods.js
+var withMethods2 = (methods) => (req, ctx, next) => {
   if (!methods.includes(req.method)) {
-    throw new MethodNotAllowedError(methods);
+    throw new MethodNotAllowedError2(methods);
   }
   return next(req, ctx);
 };
 
-// node_modules/winterspec/dist/middleware/with-input-validation.js
-import { z as z4, ZodError as ZodError2, ZodFirstPartyTypeKind as ZodFirstPartyTypeKind2 } from "zod";
+// node_modules/@tscircuit/file-server/node_modules/winterspec/dist/middleware/with-input-validation.js
+import { z as z6, ZodError as ZodError3, ZodFirstPartyTypeKind as ZodFirstPartyTypeKind3 } from "zod";
 var getZodObjectSchemaFromZodEffectSchema = (isZodEffect, schema) => {
   if (!isZodEffect) {
     return schema;
   }
   let currentSchema = schema;
-  while (currentSchema instanceof z4.ZodEffects) {
+  while (currentSchema instanceof z6.ZodEffects) {
     currentSchema = currentSchema._def.schema;
   }
   return currentSchema;
 };
 var getZodDefFromZodSchemaHelpers = (schema) => {
   const special_zod_types = [
-    ZodFirstPartyTypeKind2.ZodOptional,
-    ZodFirstPartyTypeKind2.ZodDefault,
-    ZodFirstPartyTypeKind2.ZodEffects
+    ZodFirstPartyTypeKind3.ZodOptional,
+    ZodFirstPartyTypeKind3.ZodDefault,
+    ZodFirstPartyTypeKind3.ZodEffects
   ];
   while (special_zod_types.includes(schema._def.typeName)) {
-    if (schema._def.typeName === ZodFirstPartyTypeKind2.ZodOptional || schema._def.typeName === ZodFirstPartyTypeKind2.ZodDefault) {
+    if (schema._def.typeName === ZodFirstPartyTypeKind3.ZodOptional || schema._def.typeName === ZodFirstPartyTypeKind3.ZodDefault) {
       schema = schema._def.innerType;
       continue;
     }
-    if (schema._def.typeName === ZodFirstPartyTypeKind2.ZodEffects) {
+    if (schema._def.typeName === ZodFirstPartyTypeKind3.ZodEffects) {
       schema = schema._def.schema;
       continue;
     }
@@ -250376,9 +250486,9 @@ var getZodDefFromZodSchemaHelpers = (schema) => {
   return schema._def;
 };
 var tryGetZodSchemaAsObject = (schema) => {
-  const isZodEffect = schema._def.typeName === ZodFirstPartyTypeKind2.ZodEffects;
+  const isZodEffect = schema._def.typeName === ZodFirstPartyTypeKind3.ZodEffects;
   const safe_schema = getZodObjectSchemaFromZodEffectSchema(isZodEffect, schema);
-  const isZodObject = safe_schema._def.typeName === ZodFirstPartyTypeKind2.ZodObject;
+  const isZodObject = safe_schema._def.typeName === ZodFirstPartyTypeKind3.ZodObject;
   if (!isZodObject) {
     return;
   }
@@ -250386,11 +250496,11 @@ var tryGetZodSchemaAsObject = (schema) => {
 };
 var isZodSchemaArray = (schema) => {
   const def = getZodDefFromZodSchemaHelpers(schema);
-  return def.typeName === ZodFirstPartyTypeKind2.ZodArray;
+  return def.typeName === ZodFirstPartyTypeKind3.ZodArray;
 };
 var isZodSchemaBoolean = (schema) => {
   const def = getZodDefFromZodSchemaHelpers(schema);
-  return def.typeName === ZodFirstPartyTypeKind2.ZodBoolean;
+  return def.typeName === ZodFirstPartyTypeKind3.ZodBoolean;
 };
 var parseQueryParams = (schema, input, supportedArrayFormats) => {
   const parsed_input = Object.assign({}, input);
@@ -250433,7 +250543,7 @@ var validateQueryParams = (inputUrl, schema, supportedArrayFormats) => {
     for (const [schemaKey, value] of Object.entries(obj_schema.shape)) {
       if (isZodSchemaArray(value)) {
         if (key === `${schemaKey}[]` && !supportedArrayFormats.includes("brackets")) {
-          throw new InvalidQueryParamsError(`Bracket syntax not supported for query param "${schemaKey}"`);
+          throw new InvalidQueryParamsError2(`Bracket syntax not supported for query param "${schemaKey}"`);
         }
       }
     }
@@ -250441,26 +250551,26 @@ var validateQueryParams = (inputUrl, schema, supportedArrayFormats) => {
     if (key_schema) {
       if (isZodSchemaArray(key_schema)) {
         if (seenKeys.has(key) && !supportedArrayFormats.includes("repeat")) {
-          throw new InvalidQueryParamsError(`Repeated parameters not supported for duplicate query param "${key}"`);
+          throw new InvalidQueryParamsError2(`Repeated parameters not supported for duplicate query param "${key}"`);
         }
       }
     }
     seenKeys.add(key);
   }
 };
-var withInputValidation = (input) => async (req, ctx, next) => {
+var withInputValidation2 = (input) => async (req, ctx, next) => {
   const { supportedArrayFormats } = input;
   if (input.formData && input.jsonBody || input.formData && input.commonParams) {
     throw new Error("Cannot use formData with jsonBody or commonParams");
   }
   if ((req.method === "POST" || req.method === "PATCH") && (input.jsonBody || input.commonParams) && !req.headers.get("content-type")?.includes("application/json")) {
-    throw new InvalidContentTypeError(`${req.method} requests must have Content-Type header with "application/json"`);
+    throw new InvalidContentTypeError2(`${req.method} requests must have Content-Type header with "application/json"`);
   }
   if (input.urlEncodedFormData && req.method !== "GET" && !req.headers.get("content-type")?.includes("application/x-www-form-urlencoded")) {
-    throw new InvalidContentTypeError(`Must have Content-Type header with "application/x-www-form-urlencoded"`);
+    throw new InvalidContentTypeError2(`Must have Content-Type header with "application/x-www-form-urlencoded"`);
   }
   if (input.formData && (req.method === "POST" || req.method === "PATCH") && !req.headers.get("content-type")?.includes("multipart/form-data")) {
-    throw new InvalidContentTypeError(`${req.method} requests must have Content-Type header with "multipart/form-data"`);
+    throw new InvalidContentTypeError2(`${req.method} requests must have Content-Type header with "multipart/form-data"`);
   }
   const originalParams = Object.fromEntries(new URL(req.url).searchParams.entries());
   let jsonBody;
@@ -250469,7 +250579,7 @@ var withInputValidation = (input) => async (req, ctx, next) => {
       jsonBody = await req.clone().json();
     } catch (e4) {
       if (!input.jsonBody?.isOptional()) {
-        throw new InputParsingError("Error while parsing JSON body");
+        throw new InputParsingError2("Error while parsing JSON body");
       }
     }
   }
@@ -250480,7 +250590,7 @@ var withInputValidation = (input) => async (req, ctx, next) => {
       multiPartFormData = Object.fromEntries(multiPartFormData.entries());
     } catch (e4) {
       if (!input.formData?.isOptional()) {
-        throw new InputParsingError("Error while parsing form data");
+        throw new InputParsingError2("Error while parsing form data");
       }
     }
   }
@@ -250491,7 +250601,7 @@ var withInputValidation = (input) => async (req, ctx, next) => {
       urlEncodedFormData = Object.fromEntries(params2.entries());
     } catch (e4) {
       if (!input.urlEncodedFormData?.isOptional()) {
-        throw new InputParsingError("Error while parsing url encoded form data");
+        throw new InputParsingError2("Error while parsing url encoded form data");
       }
     }
   }
@@ -250524,19 +250634,19 @@ var withInputValidation = (input) => async (req, ctx, next) => {
       req.commonParams = parseQueryParams(input.commonParams, originalCombinedParams, supportedArrayFormats);
     }
   } catch (error) {
-    if (error instanceof BadRequestError) {
+    if (error instanceof BadRequestError2) {
       throw error;
     }
-    if (error instanceof ZodError2) {
-      throw new InputValidationError(error);
+    if (error instanceof ZodError3) {
+      throw new InputValidationError2(error);
     }
-    throw new InputParsingError("Error while parsing input");
+    throw new InputParsingError2("Error while parsing input");
   }
   return next(req, ctx);
 };
 
-// node_modules/winterspec/dist/middleware/with-unhandled-exception-handling.js
-var withUnhandledExceptionHandling = async (req, ctx, next) => {
+// node_modules/@tscircuit/file-server/node_modules/winterspec/dist/middleware/with-unhandled-exception-handling.js
+var withUnhandledExceptionHandling2 = async (req, ctx, next) => {
   try {
     return await next(req, ctx);
   } catch (e4) {
@@ -250553,7 +250663,7 @@ var withUnhandledExceptionHandling = async (req, ctx, next) => {
   }
 };
 
-// node_modules/winterspec/dist/create-with-winter-spec.js
+// node_modules/@tscircuit/file-server/node_modules/winterspec/dist/create-with-winter-spec.js
 var attachMetadataToRouteFn = ({ globalSpec, routeSpec }, routeFn) => {
   routeFn._globalSpec = globalSpec;
   routeFn._routeSpec = routeSpec;
@@ -250567,16 +250677,16 @@ var createWithWinterSpec = (globalSpec) => {
     const onMultipleAuthMiddlewareFailures = globalSpec.onMultipleAuthMiddlewareFailures ?? routeSpec.onMultipleAuthMiddlewareFailures;
     const supportedAuthMiddlewares = new Set(routeSpec.auth == null || routeSpec.auth === "none" ? [] : Array.isArray(routeSpec.auth) ? routeSpec.auth : [routeSpec.auth]);
     const authMiddlewares = Object.entries(globalSpec.authMiddleware).filter(([k4, _4]) => supportedAuthMiddlewares.has(k4)).map(([_4, v3]) => v3);
-    return await wrapMiddlewares([
+    return await wrapMiddlewares2([
       ...typeof _injectedWinterSpecMiddleware !== "undefined" ? _injectedWinterSpecMiddleware : [],
-      withUnhandledExceptionHandling,
+      withUnhandledExceptionHandling2,
       serializeResponse(globalSpec, routeSpec, false),
       ...globalSpec.beforeAuthMiddleware ?? [],
       firstAuthMiddlewareThatSucceeds(authMiddlewares, onMultipleAuthMiddlewareFailures),
       ...globalSpec.afterAuthMiddleware ?? [],
       ...routeSpec.middleware ?? [],
-      withMethods(routeSpec.methods),
-      withInputValidation({
+      withMethods2(routeSpec.methods),
+      withInputValidation2({
         supportedArrayFormats: globalSpec.supportedArrayFormats ?? [
           "brackets",
           "comma",
@@ -250596,17 +250706,17 @@ var createWithWinterSpec = (globalSpec) => {
 function serializeResponse(globalSpec, routeSpec, skipValidation = false) {
   return async (req, ctx, next) => {
     const rawResponse = await next(req, ctx);
-    const statusCode = rawResponse instanceof WinterSpecResponse ? rawResponse.statusCode() : rawResponse.status;
+    const statusCode = rawResponse instanceof WinterSpecResponse2 ? rawResponse.statusCode() : rawResponse.status;
     const isSuccess = statusCode >= 200 && statusCode < 300;
     try {
       const response = serializeToResponse(isSuccess && !skipValidation && (globalSpec.shouldValidateResponses ?? true), routeSpec, rawResponse);
       return response;
     } catch (err) {
-      throw new ResponseValidationError(err);
+      throw new ResponseValidationError2(err);
     }
   };
 }
-async function wrapMiddlewares(middlewares, routeFn, request, ctx) {
+async function wrapMiddlewares2(middlewares, routeFn, request, ctx) {
   return await middlewares.reduceRight((next, middleware) => {
     return async (req, ctx2) => {
       return middleware(req, ctx2, next);
@@ -250615,17 +250725,17 @@ async function wrapMiddlewares(middlewares, routeFn, request, ctx) {
 }
 function serializeToResponse(shouldValidateResponse, routeSpec, response) {
   if (!shouldValidateResponse) {
-    return "serializeToResponse" in response ? response.serializeToResponse(z5.any()) : response;
+    return "serializeToResponse" in response ? response.serializeToResponse(z7.any()) : response;
   }
-  if (response instanceof WinterSpecResponse) {
-    if (response instanceof WinterSpecJsonResponse) {
-      return response.serializeToResponse(routeSpec.jsonResponse ?? z5.any());
+  if (response instanceof WinterSpecResponse2) {
+    if (response instanceof WinterSpecJsonResponse2) {
+      return response.serializeToResponse(routeSpec.jsonResponse ?? z7.any());
     }
-    if (response instanceof WinterSpecMultiPartFormDataResponse) {
-      return response.serializeToResponse(routeSpec.multipartFormDataResponse ?? z5.any());
+    if (response instanceof WinterSpecMultiPartFormDataResponse2) {
+      return response.serializeToResponse(routeSpec.multipartFormDataResponse ?? z7.any());
     }
-    if (response instanceof WinterSpecCustomResponse) {
-      return response.serializeToResponse(z5.any());
+    if (response instanceof WinterSpecCustomResponse2) {
+      return response.serializeToResponse(z7.any());
     }
   }
   if ("serializeToResponse" in response) {
@@ -250662,8 +250772,16 @@ function firstAuthMiddlewareThatSucceeds(authMiddlewares, onMultipleAuthMiddlewa
   };
 }
 
-// node_modules/winterspec/dist/types/winter-spec.js
-function makeRequestAgainstWinterSpec(winterSpec, options = {}) {
+// node_modules/@tscircuit/file-server/node_modules/winterspec/dist/types/context.js
+var DEFAULT_CONTEXT2 = {
+  json: WinterSpecResponse2.json,
+  multipartFormData: WinterSpecResponse2.multipartFormData,
+  custom: WinterSpecResponse2.custom
+};
+var getDefaultContext2 = () => ({ ...DEFAULT_CONTEXT2 });
+
+// node_modules/@tscircuit/file-server/node_modules/winterspec/dist/types/winter-spec.js
+function makeRequestAgainstWinterSpec2(winterSpec, options = {}) {
   return async (request) => {
     const { routeMatcher, routeMapWithHandlers, handle404 = () => new Response("Not found", {
       status: 404
@@ -250691,42 +250809,27 @@ function makeRequestAgainstWinterSpec(winterSpec, options = {}) {
     }
     const { matchedRoute, routeParams } = routeMatcher(pathname) ?? {};
     let routeFn = matchedRoute && routeMapWithHandlers[matchedRoute];
-    const winterSpecRequest = createWinterSpecRequest(request, {
+    const winterSpecRequest = createWinterSpecRequest2(request, {
       winterSpec,
       routeParams: routeParams ?? {}
     });
     if (!routeFn) {
-      return await handle404(winterSpecRequest, getDefaultContext());
+      return await handle404(winterSpecRequest, getDefaultContext2());
     }
-    return wrapMiddlewares(options.middleware ?? [], routeFn, winterSpecRequest, getDefaultContext());
+    return wrapMiddlewares2(options.middleware ?? [], routeFn, winterSpecRequest, getDefaultContext2());
   };
 }
-
-// node_modules/winterspec/dist/serve/create-winter-spec-from-route-map.js
-var import_next_route_matcher2 = __toESM2(require_dist8(), 1);
-
-// node_modules/winterspec/dist/adapters/node.js
-var EdgePrimitives = __toESM2(require_dist6(), 1);
-var getNodeHandler = (winterSpec, { port, middleware = [] }) => {
-  const transformToNode = transformToNodeBuilder({
-    defaultOrigin: `http://localhost${port ? `:${port}` : ""}`
-  });
-  return transformToNode((req) => winterSpec.makeRequest(req, {
-    middleware
-  }));
-};
-
-// node_modules/@tscircuit/file-server/dist/bundle.js
-var import_next_route_matcher3 = __toESM2(require_dist8(), 1);
-// node_modules/winterspec/dist/config/config.js
-import { z as z6 } from "zod";
-var winterSpecConfigSchema = z6.object({
-  rootDirectory: z6.string().optional(),
-  tsconfigPath: z6.string().optional(),
-  routesDirectory: z6.string().optional(),
-  platform: z6.enum(["node", "wintercg-minimal"]).default("wintercg-minimal").optional()
+// node_modules/@tscircuit/file-server/node_modules/winterspec/dist/config/config.js
+import { z as z8 } from "zod";
+var winterSpecConfigSchema = z8.object({
+  rootDirectory: z8.string().optional(),
+  tsconfigPath: z8.string().optional(),
+  routesDirectory: z8.string().optional(),
+  platform: z8.enum(["node", "wintercg-minimal"]).default("wintercg-minimal").optional()
 }).strict();
-// node_modules/zustand/esm/vanilla.mjs
+// node_modules/@tscircuit/file-server/node_modules/winterspec/dist/serve/create-winter-spec-from-route-map.js
+var import_next_route_matcher3 = __toESM2(require_dist8(), 1);
+// node_modules/@tscircuit/file-server/node_modules/zustand/esm/vanilla.mjs
 var createStoreImpl = (createState) => {
   let state;
   const listeners = /* @__PURE__ */ new Set;
@@ -250793,20 +250896,20 @@ var hoist = (store) => {
   return hoistState(hoistActions(store));
 };
 
-// node_modules/zustand/esm/middleware.mjs
+// node_modules/@tscircuit/file-server/node_modules/zustand/esm/middleware.mjs
 var combine = (initialState, create) => (...a2) => Object.assign({}, initialState, create(...a2));
 
 // node_modules/@tscircuit/file-server/dist/bundle.js
-import { z as z7 } from "zod";
+import { z as z10 } from "zod";
 import { z as z24 } from "zod";
 import { z as z32 } from "zod";
 import { z as z42 } from "zod";
 import { z as z52 } from "zod";
 import { z as z62 } from "zod";
 import { z as z72 } from "zod";
-import { z as z8 } from "zod";
+import { z as z82 } from "zod";
 import { z as z92 } from "zod";
-import { z as z10 } from "zod";
+import { z as z102 } from "zod";
 import { z as z11 } from "zod";
 import { Buffer as Buffer2 } from "node:buffer";
 import { z as z12 } from "zod";
@@ -250818,31 +250921,31 @@ import { z as z17 } from "zod";
 import { z as z18 } from "zod";
 import { z as z19 } from "zod";
 import { z as z20 } from "zod";
-var fileSchema = z7.object({
-  file_id: z7.string(),
-  file_path: z7.string(),
-  text_content: z7.string().optional(),
-  binary_content_b64: z7.string().optional(),
-  created_at: z7.string()
+var fileSchema = z10.object({
+  file_id: z10.string(),
+  file_path: z10.string(),
+  text_content: z10.string().optional(),
+  binary_content_b64: z10.string().optional(),
+  created_at: z10.string()
 }).refine((data) => data.text_content !== undefined !== (data.binary_content_b64 !== undefined), {
   message: "Provide either text_content or binary_content_b64",
   path: ["text_content"]
 });
-var eventSchema = z7.object({
-  event_id: z7.string(),
-  event_type: z7.union([
-    z7.literal("FILE_UPDATED"),
-    z7.literal("FILE_DELETED"),
-    z7.literal("FILE_CREATED")
+var eventSchema = z10.object({
+  event_id: z10.string(),
+  event_type: z10.union([
+    z10.literal("FILE_UPDATED"),
+    z10.literal("FILE_DELETED"),
+    z10.literal("FILE_CREATED")
   ]),
-  file_path: z7.string(),
-  created_at: z7.string(),
-  initiator: z7.string().optional()
+  file_path: z10.string(),
+  created_at: z10.string(),
+  initiator: z10.string().optional()
 });
-var databaseSchema = z7.object({
-  idCounter: z7.number().default(0),
-  files: z7.array(fileSchema).default([]),
-  events: z7.array(eventSchema).default([])
+var databaseSchema = z10.object({
+  idCounter: z10.number().default(0),
+  files: z10.array(fileSchema).default([]),
+  events: z10.array(eventSchema).default([])
 });
 function normalizePath2(path52) {
   if (!path52 || path52 === "/")
@@ -251272,16 +251375,16 @@ var create_default2 = withRouteSpec({
 });
 var list_default3 = withRouteSpec({
   methods: ["GET"],
-  queryParams: z8.object({
-    since: z8.string().optional(),
-    event_type: z8.string().optional()
+  queryParams: z82.object({
+    since: z82.string().optional(),
+    event_type: z82.string().optional()
   }),
-  jsonResponse: z8.object({
-    event_list: z8.array(z8.object({
-      event_id: z8.string(),
-      event_type: z8.string(),
-      file_path: z8.string().optional(),
-      created_at: z8.string()
+  jsonResponse: z82.object({
+    event_list: z82.array(z82.object({
+      event_id: z82.string(),
+      event_type: z82.string(),
+      file_path: z82.string().optional(),
+      created_at: z82.string()
     }).passthrough())
   })
 })((req, ctx) => {
@@ -251299,12 +251402,12 @@ var reset_default = withRouteSpec({
 });
 var delete_default = withRouteSpec({
   methods: ["POST", "DELETE"],
-  commonParams: z10.object({
-    file_id: z10.string().optional(),
-    file_path: z10.string().optional(),
-    initiator: z10.string().optional()
+  commonParams: z102.object({
+    file_id: z102.string().optional(),
+    file_path: z102.string().optional(),
+    initiator: z102.string().optional()
   }),
-  jsonResponse: z10.union([z10.null(), z10.object({ error: z10.string() })])
+  jsonResponse: z102.union([z102.null(), z102.object({ error: z102.string() })])
 })(async (req, ctx) => {
   const { file_id, file_path, initiator } = req.commonParams;
   if (!file_id && !file_path) {
@@ -251670,9 +251773,9 @@ var routeMapWithHandlers = {
   "/": routes_default
 };
 var winterSpec = {
-  routeMatcher: import_next_route_matcher3.getRouteMatcher(Object.keys(routeMapWithHandlers)),
+  routeMatcher: import_next_route_matcher4.getRouteMatcher(Object.keys(routeMapWithHandlers)),
   routeMapWithHandlers,
-  makeRequest: async (req, options) => makeRequestAgainstWinterSpec(winterSpec, options)(req)
+  makeRequest: async (req, options) => makeRequestAgainstWinterSpec2(winterSpec, options)(req)
 };
 var stdin_default = winterSpec;
 
@@ -254185,9 +254288,9 @@ import { z as z43 } from "zod";
 import { z as z53 } from "zod";
 import { z as z63 } from "zod";
 import { z as z73 } from "zod";
-import { z as z82 } from "zod";
+import { z as z83 } from "zod";
 import { z as z93 } from "zod";
-import { z as z102 } from "zod";
+import { z as z103 } from "zod";
 import { z as z112 } from "zod";
 import { z as z122 } from "zod";
 import { z as z132 } from "zod";
@@ -254302,8 +254405,8 @@ var M15 = defineExcellonDrillCommand({
 });
 var M16 = defineExcellonDrillCommand({
   command_code: "M16",
-  schema: z82.object({
-    command_code: z82.literal("M16").default("M16")
+  schema: z83.object({
+    command_code: z83.literal("M16").default("M16")
   }),
   stringify: () => "M16"
 });
@@ -254316,8 +254419,8 @@ var M30 = defineExcellonDrillCommand({
 });
 var M48 = defineExcellonDrillCommand({
   command_code: "M48",
-  schema: z102.object({
-    command_code: z102.literal("M48").default("M48")
+  schema: z103.object({
+    command_code: z103.literal("M48").default("M48")
   }),
   stringify: () => "M48"
 });
@@ -257147,8 +257250,8 @@ __export4(external_exports2, {
   ZodDiscriminatedUnion: () => ZodDiscriminatedUnion2,
   ZodEffects: () => ZodEffects2,
   ZodEnum: () => ZodEnum2,
-  ZodError: () => ZodError3,
-  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind3,
+  ZodError: () => ZodError4,
+  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind4,
   ZodFunction: () => ZodFunction2,
   ZodIntersection: () => ZodIntersection2,
   ZodIssueCode: () => ZodIssueCode2,
@@ -257387,7 +257490,7 @@ var quotelessJson2 = (obj) => {
   const json2 = JSON.stringify(obj, null, 2);
   return json2.replace(/"([^"]+)":/g, "$1:");
 };
-var ZodError3 = class _ZodError2 extends Error {
+var ZodError4 = class _ZodError2 extends Error {
   get errors() {
     return this.issues;
   }
@@ -257477,8 +257580,8 @@ var ZodError3 = class _ZodError2 extends Error {
     return this.flatten();
   }
 };
-ZodError3.create = (issues) => {
-  const error = new ZodError3(issues);
+ZodError4.create = (issues) => {
+  const error = new ZodError4(issues);
   return error;
 };
 var errorMap2 = (issue, _ctx) => {
@@ -257729,7 +257832,7 @@ var handleResult2 = (ctx, result) => {
       get error() {
         if (this._error)
           return this._error;
-        const error = new ZodError3(ctx.common.issues);
+        const error = new ZodError4(ctx.common.issues);
         this._error = error;
         return this._error;
       }
@@ -257928,7 +258031,7 @@ var ZodType2 = class {
   _refinement(refinement) {
     return new ZodEffects2({
       schema: this,
-      typeName: ZodFirstPartyTypeKind3.ZodEffects,
+      typeName: ZodFirstPartyTypeKind4.ZodEffects,
       effect: { type: "refinement", refinement }
     });
   }
@@ -257993,7 +258096,7 @@ var ZodType2 = class {
     return new ZodEffects2({
       ...processCreateParams2(this._def),
       schema: this,
-      typeName: ZodFirstPartyTypeKind3.ZodEffects,
+      typeName: ZodFirstPartyTypeKind4.ZodEffects,
       effect: { type: "transform", transform: transform2 }
     });
   }
@@ -258003,12 +258106,12 @@ var ZodType2 = class {
       ...processCreateParams2(this._def),
       innerType: this,
       defaultValue: defaultValueFunc,
-      typeName: ZodFirstPartyTypeKind3.ZodDefault
+      typeName: ZodFirstPartyTypeKind4.ZodDefault
     });
   }
   brand() {
     return new ZodBranded2({
-      typeName: ZodFirstPartyTypeKind3.ZodBranded,
+      typeName: ZodFirstPartyTypeKind4.ZodBranded,
       type: this,
       ...processCreateParams2(this._def)
     });
@@ -258019,7 +258122,7 @@ var ZodType2 = class {
       ...processCreateParams2(this._def),
       innerType: this,
       catchValue: catchValueFunc,
-      typeName: ZodFirstPartyTypeKind3.ZodCatch
+      typeName: ZodFirstPartyTypeKind4.ZodCatch
     });
   }
   describe(description) {
@@ -258660,7 +258763,7 @@ var ZodString2 = class _ZodString2 extends ZodType2 {
 ZodString2.create = (params2) => {
   return new ZodString2({
     checks: [],
-    typeName: ZodFirstPartyTypeKind3.ZodString,
+    typeName: ZodFirstPartyTypeKind4.ZodString,
     coerce: params2?.coerce ?? false,
     ...processCreateParams2(params2)
   });
@@ -258900,7 +259003,7 @@ var ZodNumber2 = class _ZodNumber2 extends ZodType2 {
 ZodNumber2.create = (params2) => {
   return new ZodNumber2({
     checks: [],
-    typeName: ZodFirstPartyTypeKind3.ZodNumber,
+    typeName: ZodFirstPartyTypeKind4.ZodNumber,
     coerce: params2?.coerce || false,
     ...processCreateParams2(params2)
   });
@@ -259072,7 +259175,7 @@ var ZodBigInt2 = class _ZodBigInt2 extends ZodType2 {
 ZodBigInt2.create = (params2) => {
   return new ZodBigInt2({
     checks: [],
-    typeName: ZodFirstPartyTypeKind3.ZodBigInt,
+    typeName: ZodFirstPartyTypeKind4.ZodBigInt,
     coerce: params2?.coerce ?? false,
     ...processCreateParams2(params2)
   });
@@ -259097,7 +259200,7 @@ var ZodBoolean2 = class extends ZodType2 {
 };
 ZodBoolean2.create = (params2) => {
   return new ZodBoolean2({
-    typeName: ZodFirstPartyTypeKind3.ZodBoolean,
+    typeName: ZodFirstPartyTypeKind4.ZodBoolean,
     coerce: params2?.coerce || false,
     ...processCreateParams2(params2)
   });
@@ -259207,7 +259310,7 @@ ZodDate2.create = (params2) => {
   return new ZodDate2({
     checks: [],
     coerce: params2?.coerce || false,
-    typeName: ZodFirstPartyTypeKind3.ZodDate,
+    typeName: ZodFirstPartyTypeKind4.ZodDate,
     ...processCreateParams2(params2)
   });
 };
@@ -259228,7 +259331,7 @@ var ZodSymbol2 = class extends ZodType2 {
 };
 ZodSymbol2.create = (params2) => {
   return new ZodSymbol2({
-    typeName: ZodFirstPartyTypeKind3.ZodSymbol,
+    typeName: ZodFirstPartyTypeKind4.ZodSymbol,
     ...processCreateParams2(params2)
   });
 };
@@ -259249,7 +259352,7 @@ var ZodUndefined2 = class extends ZodType2 {
 };
 ZodUndefined2.create = (params2) => {
   return new ZodUndefined2({
-    typeName: ZodFirstPartyTypeKind3.ZodUndefined,
+    typeName: ZodFirstPartyTypeKind4.ZodUndefined,
     ...processCreateParams2(params2)
   });
 };
@@ -259270,7 +259373,7 @@ var ZodNull2 = class extends ZodType2 {
 };
 ZodNull2.create = (params2) => {
   return new ZodNull2({
-    typeName: ZodFirstPartyTypeKind3.ZodNull,
+    typeName: ZodFirstPartyTypeKind4.ZodNull,
     ...processCreateParams2(params2)
   });
 };
@@ -259285,7 +259388,7 @@ var ZodAny2 = class extends ZodType2 {
 };
 ZodAny2.create = (params2) => {
   return new ZodAny2({
-    typeName: ZodFirstPartyTypeKind3.ZodAny,
+    typeName: ZodFirstPartyTypeKind4.ZodAny,
     ...processCreateParams2(params2)
   });
 };
@@ -259300,7 +259403,7 @@ var ZodUnknown2 = class extends ZodType2 {
 };
 ZodUnknown2.create = (params2) => {
   return new ZodUnknown2({
-    typeName: ZodFirstPartyTypeKind3.ZodUnknown,
+    typeName: ZodFirstPartyTypeKind4.ZodUnknown,
     ...processCreateParams2(params2)
   });
 };
@@ -259317,7 +259420,7 @@ var ZodNever2 = class extends ZodType2 {
 };
 ZodNever2.create = (params2) => {
   return new ZodNever2({
-    typeName: ZodFirstPartyTypeKind3.ZodNever,
+    typeName: ZodFirstPartyTypeKind4.ZodNever,
     ...processCreateParams2(params2)
   });
 };
@@ -259338,7 +259441,7 @@ var ZodVoid2 = class extends ZodType2 {
 };
 ZodVoid2.create = (params2) => {
   return new ZodVoid2({
-    typeName: ZodFirstPartyTypeKind3.ZodVoid,
+    typeName: ZodFirstPartyTypeKind4.ZodVoid,
     ...processCreateParams2(params2)
   });
 };
@@ -259439,7 +259542,7 @@ ZodArray2.create = (schema, params2) => {
     minLength: null,
     maxLength: null,
     exactLength: null,
-    typeName: ZodFirstPartyTypeKind3.ZodArray,
+    typeName: ZodFirstPartyTypeKind4.ZodArray,
     ...processCreateParams2(params2)
   });
 };
@@ -259617,7 +259720,7 @@ var ZodObject2 = class _ZodObject2 extends ZodType2 {
         ...this._def.shape(),
         ...merging._def.shape()
       }),
-      typeName: ZodFirstPartyTypeKind3.ZodObject
+      typeName: ZodFirstPartyTypeKind4.ZodObject
     });
     return merged;
   }
@@ -259700,7 +259803,7 @@ ZodObject2.create = (shape, params2) => {
     shape: () => shape,
     unknownKeys: "strip",
     catchall: ZodNever2.create(),
-    typeName: ZodFirstPartyTypeKind3.ZodObject,
+    typeName: ZodFirstPartyTypeKind4.ZodObject,
     ...processCreateParams2(params2)
   });
 };
@@ -259709,7 +259812,7 @@ ZodObject2.strictCreate = (shape, params2) => {
     shape: () => shape,
     unknownKeys: "strict",
     catchall: ZodNever2.create(),
-    typeName: ZodFirstPartyTypeKind3.ZodObject,
+    typeName: ZodFirstPartyTypeKind4.ZodObject,
     ...processCreateParams2(params2)
   });
 };
@@ -259718,7 +259821,7 @@ ZodObject2.lazycreate = (shape, params2) => {
     shape,
     unknownKeys: "strip",
     catchall: ZodNever2.create(),
-    typeName: ZodFirstPartyTypeKind3.ZodObject,
+    typeName: ZodFirstPartyTypeKind4.ZodObject,
     ...processCreateParams2(params2)
   });
 };
@@ -259738,7 +259841,7 @@ var ZodUnion2 = class extends ZodType2 {
           return result.result;
         }
       }
-      const unionErrors = results.map((result) => new ZodError3(result.ctx.common.issues));
+      const unionErrors = results.map((result) => new ZodError4(result.ctx.common.issues));
       addIssueToContext2(ctx, {
         code: ZodIssueCode2.invalid_union,
         unionErrors
@@ -259794,7 +259897,7 @@ var ZodUnion2 = class extends ZodType2 {
         ctx.common.issues.push(...dirty.ctx.common.issues);
         return dirty.result;
       }
-      const unionErrors = issues.map((issues2) => new ZodError3(issues2));
+      const unionErrors = issues.map((issues2) => new ZodError4(issues2));
       addIssueToContext2(ctx, {
         code: ZodIssueCode2.invalid_union,
         unionErrors
@@ -259809,7 +259912,7 @@ var ZodUnion2 = class extends ZodType2 {
 ZodUnion2.create = (types2, params2) => {
   return new ZodUnion2({
     options: types2,
-    typeName: ZodFirstPartyTypeKind3.ZodUnion,
+    typeName: ZodFirstPartyTypeKind4.ZodUnion,
     ...processCreateParams2(params2)
   });
 };
@@ -259904,7 +260007,7 @@ var ZodDiscriminatedUnion2 = class _ZodDiscriminatedUnion2 extends ZodType2 {
       }
     }
     return new _ZodDiscriminatedUnion2({
-      typeName: ZodFirstPartyTypeKind3.ZodDiscriminatedUnion,
+      typeName: ZodFirstPartyTypeKind4.ZodDiscriminatedUnion,
       discriminator,
       options,
       optionsMap,
@@ -259999,7 +260102,7 @@ ZodIntersection2.create = (left, right, params2) => {
   return new ZodIntersection2({
     left,
     right,
-    typeName: ZodFirstPartyTypeKind3.ZodIntersection,
+    typeName: ZodFirstPartyTypeKind4.ZodIntersection,
     ...processCreateParams2(params2)
   });
 };
@@ -260065,7 +260168,7 @@ ZodTuple2.create = (schemas, params2) => {
   }
   return new ZodTuple2({
     items: schemas,
-    typeName: ZodFirstPartyTypeKind3.ZodTuple,
+    typeName: ZodFirstPartyTypeKind4.ZodTuple,
     rest: null,
     ...processCreateParams2(params2)
   });
@@ -260111,14 +260214,14 @@ var ZodRecord2 = class _ZodRecord2 extends ZodType2 {
       return new _ZodRecord2({
         keyType: first,
         valueType: second,
-        typeName: ZodFirstPartyTypeKind3.ZodRecord,
+        typeName: ZodFirstPartyTypeKind4.ZodRecord,
         ...processCreateParams2(third)
       });
     }
     return new _ZodRecord2({
       keyType: ZodString2.create(),
       valueType: first,
-      typeName: ZodFirstPartyTypeKind3.ZodRecord,
+      typeName: ZodFirstPartyTypeKind4.ZodRecord,
       ...processCreateParams2(second)
     });
   }
@@ -260185,7 +260288,7 @@ ZodMap2.create = (keyType, valueType, params2) => {
   return new ZodMap2({
     valueType,
     keyType,
-    typeName: ZodFirstPartyTypeKind3.ZodMap,
+    typeName: ZodFirstPartyTypeKind4.ZodMap,
     ...processCreateParams2(params2)
   });
 };
@@ -260270,7 +260373,7 @@ ZodSet2.create = (valueType, params2) => {
     valueType,
     minSize: null,
     maxSize: null,
-    typeName: ZodFirstPartyTypeKind3.ZodSet,
+    typeName: ZodFirstPartyTypeKind4.ZodSet,
     ...processCreateParams2(params2)
   });
 };
@@ -260316,7 +260419,7 @@ var ZodFunction2 = class _ZodFunction2 extends ZodType2 {
     if (this._def.returns instanceof ZodPromise2) {
       const me3 = this;
       return OK2(async function(...args) {
-        const error = new ZodError3([]);
+        const error = new ZodError4([]);
         const parsedArgs = await me3._def.args.parseAsync(args, params2).catch((e4) => {
           error.addIssue(makeArgsIssue(args, e4));
           throw error;
@@ -260333,12 +260436,12 @@ var ZodFunction2 = class _ZodFunction2 extends ZodType2 {
       return OK2(function(...args) {
         const parsedArgs = me3._def.args.safeParse(args, params2);
         if (!parsedArgs.success) {
-          throw new ZodError3([makeArgsIssue(args, parsedArgs.error)]);
+          throw new ZodError4([makeArgsIssue(args, parsedArgs.error)]);
         }
         const result = Reflect.apply(fn3, this, parsedArgs.data);
         const parsedReturns = me3._def.returns.safeParse(result, params2);
         if (!parsedReturns.success) {
-          throw new ZodError3([makeReturnsIssue(result, parsedReturns.error)]);
+          throw new ZodError4([makeReturnsIssue(result, parsedReturns.error)]);
         }
         return parsedReturns.data;
       });
@@ -260374,7 +260477,7 @@ var ZodFunction2 = class _ZodFunction2 extends ZodType2 {
     return new _ZodFunction2({
       args: args ? args : ZodTuple2.create([]).rest(ZodUnknown2.create()),
       returns: returns || ZodUnknown2.create(),
-      typeName: ZodFirstPartyTypeKind3.ZodFunction,
+      typeName: ZodFirstPartyTypeKind4.ZodFunction,
       ...processCreateParams2(params2)
     });
   }
@@ -260392,7 +260495,7 @@ var ZodLazy2 = class extends ZodType2 {
 ZodLazy2.create = (getter, params2) => {
   return new ZodLazy2({
     getter,
-    typeName: ZodFirstPartyTypeKind3.ZodLazy,
+    typeName: ZodFirstPartyTypeKind4.ZodLazy,
     ...processCreateParams2(params2)
   });
 };
@@ -260416,14 +260519,14 @@ var ZodLiteral2 = class extends ZodType2 {
 ZodLiteral2.create = (value, params2) => {
   return new ZodLiteral2({
     value,
-    typeName: ZodFirstPartyTypeKind3.ZodLiteral,
+    typeName: ZodFirstPartyTypeKind4.ZodLiteral,
     ...processCreateParams2(params2)
   });
 };
 function createZodEnum2(values, params2) {
   return new ZodEnum2({
     values,
-    typeName: ZodFirstPartyTypeKind3.ZodEnum,
+    typeName: ZodFirstPartyTypeKind4.ZodEnum,
     ...processCreateParams2(params2)
   });
 }
@@ -260526,7 +260629,7 @@ var ZodNativeEnum2 = class extends ZodType2 {
 ZodNativeEnum2.create = (values, params2) => {
   return new ZodNativeEnum2({
     values,
-    typeName: ZodFirstPartyTypeKind3.ZodNativeEnum,
+    typeName: ZodFirstPartyTypeKind4.ZodNativeEnum,
     ...processCreateParams2(params2)
   });
 };
@@ -260556,7 +260659,7 @@ var ZodPromise2 = class extends ZodType2 {
 ZodPromise2.create = (schema, params2) => {
   return new ZodPromise2({
     type: schema,
-    typeName: ZodFirstPartyTypeKind3.ZodPromise,
+    typeName: ZodFirstPartyTypeKind4.ZodPromise,
     ...processCreateParams2(params2)
   });
 };
@@ -260565,7 +260668,7 @@ var ZodEffects2 = class extends ZodType2 {
     return this._def.schema;
   }
   sourceType() {
-    return this._def.schema._def.typeName === ZodFirstPartyTypeKind3.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
+    return this._def.schema._def.typeName === ZodFirstPartyTypeKind4.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
   }
   _parse(input) {
     const { status, ctx } = this._processInputParams(input);
@@ -260686,7 +260789,7 @@ var ZodEffects2 = class extends ZodType2 {
 ZodEffects2.create = (schema, effect, params2) => {
   return new ZodEffects2({
     schema,
-    typeName: ZodFirstPartyTypeKind3.ZodEffects,
+    typeName: ZodFirstPartyTypeKind4.ZodEffects,
     effect,
     ...processCreateParams2(params2)
   });
@@ -260695,7 +260798,7 @@ ZodEffects2.createWithPreprocess = (preprocess, schema, params2) => {
   return new ZodEffects2({
     schema,
     effect: { type: "preprocess", transform: preprocess },
-    typeName: ZodFirstPartyTypeKind3.ZodEffects,
+    typeName: ZodFirstPartyTypeKind4.ZodEffects,
     ...processCreateParams2(params2)
   });
 };
@@ -260714,7 +260817,7 @@ var ZodOptional2 = class extends ZodType2 {
 ZodOptional2.create = (type, params2) => {
   return new ZodOptional2({
     innerType: type,
-    typeName: ZodFirstPartyTypeKind3.ZodOptional,
+    typeName: ZodFirstPartyTypeKind4.ZodOptional,
     ...processCreateParams2(params2)
   });
 };
@@ -260733,7 +260836,7 @@ var ZodNullable2 = class extends ZodType2 {
 ZodNullable2.create = (type, params2) => {
   return new ZodNullable2({
     innerType: type,
-    typeName: ZodFirstPartyTypeKind3.ZodNullable,
+    typeName: ZodFirstPartyTypeKind4.ZodNullable,
     ...processCreateParams2(params2)
   });
 };
@@ -260757,7 +260860,7 @@ var ZodDefault2 = class extends ZodType2 {
 ZodDefault2.create = (type, params2) => {
   return new ZodDefault2({
     innerType: type,
-    typeName: ZodFirstPartyTypeKind3.ZodDefault,
+    typeName: ZodFirstPartyTypeKind4.ZodDefault,
     defaultValue: typeof params2.default === "function" ? params2.default : () => params2.default,
     ...processCreateParams2(params2)
   });
@@ -260785,7 +260888,7 @@ var ZodCatch2 = class extends ZodType2 {
           status: "valid",
           value: result2.status === "valid" ? result2.value : this._def.catchValue({
             get error() {
-              return new ZodError3(newCtx.common.issues);
+              return new ZodError4(newCtx.common.issues);
             },
             input: newCtx.data
           })
@@ -260796,7 +260899,7 @@ var ZodCatch2 = class extends ZodType2 {
         status: "valid",
         value: result.status === "valid" ? result.value : this._def.catchValue({
           get error() {
-            return new ZodError3(newCtx.common.issues);
+            return new ZodError4(newCtx.common.issues);
           },
           input: newCtx.data
         })
@@ -260810,7 +260913,7 @@ var ZodCatch2 = class extends ZodType2 {
 ZodCatch2.create = (type, params2) => {
   return new ZodCatch2({
     innerType: type,
-    typeName: ZodFirstPartyTypeKind3.ZodCatch,
+    typeName: ZodFirstPartyTypeKind4.ZodCatch,
     catchValue: typeof params2.catch === "function" ? params2.catch : () => params2.catch,
     ...processCreateParams2(params2)
   });
@@ -260832,7 +260935,7 @@ var ZodNaN2 = class extends ZodType2 {
 };
 ZodNaN2.create = (params2) => {
   return new ZodNaN2({
-    typeName: ZodFirstPartyTypeKind3.ZodNaN,
+    typeName: ZodFirstPartyTypeKind4.ZodNaN,
     ...processCreateParams2(params2)
   });
 };
@@ -260902,7 +261005,7 @@ var ZodPipeline2 = class _ZodPipeline2 extends ZodType2 {
     return new _ZodPipeline2({
       in: a2,
       out: b,
-      typeName: ZodFirstPartyTypeKind3.ZodPipeline
+      typeName: ZodFirstPartyTypeKind4.ZodPipeline
     });
   }
 };
@@ -260924,7 +261027,7 @@ var ZodReadonly2 = class extends ZodType2 {
 ZodReadonly2.create = (type, params2) => {
   return new ZodReadonly2({
     innerType: type,
-    typeName: ZodFirstPartyTypeKind3.ZodReadonly,
+    typeName: ZodFirstPartyTypeKind4.ZodReadonly,
     ...processCreateParams2(params2)
   });
 };
@@ -260958,7 +261061,7 @@ function custom2(check, _params = {}, fatal) {
 var late2 = {
   object: ZodObject2.lazycreate
 };
-var ZodFirstPartyTypeKind3;
+var ZodFirstPartyTypeKind4;
 (function(ZodFirstPartyTypeKind22) {
   ZodFirstPartyTypeKind22["ZodString"] = "ZodString";
   ZodFirstPartyTypeKind22["ZodNumber"] = "ZodNumber";
@@ -260996,7 +261099,7 @@ var ZodFirstPartyTypeKind3;
   ZodFirstPartyTypeKind22["ZodBranded"] = "ZodBranded";
   ZodFirstPartyTypeKind22["ZodPipeline"] = "ZodPipeline";
   ZodFirstPartyTypeKind22["ZodReadonly"] = "ZodReadonly";
-})(ZodFirstPartyTypeKind3 || (ZodFirstPartyTypeKind3 = {}));
+})(ZodFirstPartyTypeKind4 || (ZodFirstPartyTypeKind4 = {}));
 var instanceOfType2 = (cls, params2 = {
   message: `Input not instance of ${cls.name}`
 }) => custom2((data) => data instanceof cls, params2);
@@ -267444,9 +267547,9 @@ import { z as z410 } from "zod";
 import { z as z54 } from "zod";
 import { z as z64 } from "zod";
 import { z as z74 } from "zod";
-import { z as z83 } from "zod";
+import { z as z84 } from "zod";
 import { z as z94 } from "zod";
-import { z as z103 } from "zod";
+import { z as z104 } from "zod";
 import { z as z113 } from "zod";
 import { z as z143 } from "zod";
 import { z as z123 } from "zod";
@@ -267520,7 +267623,7 @@ import { z as z80 } from "zod";
 import { z as z81 } from "zod";
 import { z as z822 } from "zod";
 import { z as z832 } from "zod";
-import { z as z84 } from "zod";
+import { z as z842 } from "zod";
 import { z as z85 } from "zod";
 import { z as z86 } from "zod";
 import { z as z87 } from "zod";
@@ -267540,7 +267643,7 @@ import { z as z100 } from "zod";
 import { z as z101 } from "zod";
 import { z as z1022 } from "zod";
 import { z as z1032 } from "zod";
-import { z as z104 } from "zod";
+import { z as z1042 } from "zod";
 import { z as z105 } from "zod";
 import { z as z106 } from "zod";
 import { z as z107 } from "zod";
@@ -268148,10 +268251,10 @@ var pcbRenderLayer3 = z74.enum([
   "drill"
 ]);
 expectTypesMatch4(true);
-var asset3 = z83.object({
-  project_relative_path: z83.string(),
-  url: z83.string(),
-  mimetype: z83.string()
+var asset3 = z84.object({
+  project_relative_path: z84.string(),
+  url: z84.string(),
+  mimetype: z84.string()
 });
 expectTypesMatch4(true);
 var kicadAt4 = point7.extend({
@@ -268222,29 +268325,29 @@ var kicadFootprintMetadata4 = z94.object({
   model: kicadFootprintModel4.optional()
 });
 expectTypesMatch4(true);
-var kicadSymbolPinNumbers4 = z103.object({
-  hide: z103.boolean().optional()
+var kicadSymbolPinNumbers4 = z104.object({
+  hide: z104.boolean().optional()
 });
 expectTypesMatch4(true);
-var kicadSymbolPinNames4 = z103.object({
+var kicadSymbolPinNames4 = z104.object({
   offset: distance8.optional(),
-  hide: z103.boolean().optional()
+  hide: z104.boolean().optional()
 });
 expectTypesMatch4(true);
-var kicadSymbolEffects4 = z103.object({
+var kicadSymbolEffects4 = z104.object({
   font: kicadFont4.optional(),
-  justify: z103.union([z103.string(), z103.array(z103.string())]).optional(),
-  hide: z103.boolean().optional()
+  justify: z104.union([z104.string(), z104.array(z104.string())]).optional(),
+  hide: z104.boolean().optional()
 });
 expectTypesMatch4(true);
-var kicadSymbolProperty4 = z103.object({
-  value: z103.string(),
-  id: z103.union([z103.number(), z103.string()]).optional(),
+var kicadSymbolProperty4 = z104.object({
+  value: z104.string(),
+  id: z104.union([z104.number(), z104.string()]).optional(),
   at: kicadAt4.optional(),
   effects: kicadSymbolEffects4.optional()
 });
 expectTypesMatch4(true);
-var kicadSymbolProperties4 = z103.object({
+var kicadSymbolProperties4 = z104.object({
   Reference: kicadSymbolProperty4.optional(),
   Value: kicadSymbolProperty4.optional(),
   Footprint: kicadSymbolProperty4.optional(),
@@ -268254,16 +268357,16 @@ var kicadSymbolProperties4 = z103.object({
   ki_fp_filters: kicadSymbolProperty4.optional()
 });
 expectTypesMatch4(true);
-var kicadSymbolMetadata4 = z103.object({
-  symbolName: z103.string().optional(),
-  extends: z103.string().optional(),
+var kicadSymbolMetadata4 = z104.object({
+  symbolName: z104.string().optional(),
+  extends: z104.string().optional(),
   pinNumbers: kicadSymbolPinNumbers4.optional(),
   pinNames: kicadSymbolPinNames4.optional(),
-  excludeFromSim: z103.boolean().optional(),
-  inBom: z103.boolean().optional(),
-  onBoard: z103.boolean().optional(),
+  excludeFromSim: z104.boolean().optional(),
+  inBom: z104.boolean().optional(),
+  onBoard: z104.boolean().optional(),
   properties: kicadSymbolProperties4.optional(),
-  embeddedFonts: z103.boolean().optional()
+  embeddedFonts: z104.boolean().optional()
 });
 expectTypesMatch4(true);
 var base_circuit_json_error3 = z113.object({
@@ -269075,19 +269178,19 @@ var schematic_manual_edit_conflict_warning3 = z832.object({
   source_component_id: z832.string()
 }).describe("Warning emitted when a component has both manual placement and explicit schX/schY coordinates");
 expectTypesMatch4(true);
-var schematic_group3 = z84.object({
-  type: z84.literal("schematic_group"),
+var schematic_group3 = z842.object({
+  type: z842.literal("schematic_group"),
   schematic_group_id: getZodPrefixedIdWithDefault3("schematic_group"),
-  source_group_id: z84.string(),
-  is_subcircuit: z84.boolean().optional(),
-  subcircuit_id: z84.string().optional(),
+  source_group_id: z842.string(),
+  is_subcircuit: z842.boolean().optional(),
+  subcircuit_id: z842.string().optional(),
   width: length3,
   height: length3,
   center: point7,
-  schematic_component_ids: z84.array(z84.string()),
-  show_as_schematic_box: z84.boolean().optional(),
-  name: z84.string().optional(),
-  description: z84.string().optional()
+  schematic_component_ids: z842.array(z842.string()),
+  show_as_schematic_box: z842.boolean().optional(),
+  name: z842.string().optional(),
+  description: z842.string().optional()
 }).describe("Defines a group of components on the schematic");
 expectTypesMatch4(true);
 var schematic_table3 = z85.object({
@@ -269766,23 +269869,23 @@ var pcb_net3 = z1032.object({
   highlight_color: z1032.string().optional()
 }).describe("Defines a net on the PCB");
 expectTypesMatch4(true);
-var pcb_via3 = z104.object({
-  type: z104.literal("pcb_via"),
+var pcb_via3 = z1042.object({
+  type: z1042.literal("pcb_via"),
   pcb_via_id: getZodPrefixedIdWithDefault3("pcb_via"),
-  pcb_group_id: z104.string().optional(),
-  subcircuit_id: z104.string().optional(),
-  subcircuit_connectivity_map_key: z104.string().optional(),
+  pcb_group_id: z1042.string().optional(),
+  subcircuit_id: z1042.string().optional(),
+  subcircuit_connectivity_map_key: z1042.string().optional(),
   x: distance8,
   y: distance8,
   outer_diameter: distance8.default("0.6mm"),
   hole_diameter: distance8.default("0.25mm"),
   from_layer: layer_ref3.optional(),
   to_layer: layer_ref3.optional(),
-  layers: z104.array(layer_ref3),
-  pcb_trace_id: z104.string().optional(),
-  net_is_assignable: z104.boolean().optional(),
-  net_assigned: z104.boolean().optional(),
-  is_tented: z104.boolean().optional()
+  layers: z1042.array(layer_ref3),
+  pcb_trace_id: z1042.string().optional(),
+  net_is_assignable: z1042.boolean().optional(),
+  net_assigned: z1042.boolean().optional(),
+  is_tented: z1042.boolean().optional()
 }).describe("Defines a via on the PCB");
 expectTypesMatch4(true);
 var pcb_board3 = z105.object({
@@ -277330,17 +277433,317 @@ Fuse2.use = function(...plugins) {
   plugins.forEach((plugin) => register2(plugin));
 };
 var entry_default = Fuse2;
+// node_modules/@tscircuit/ti-parts-engine/lib/kicad-archive/readKicadArchive.ts
+var import_jszip6 = __toESM2(require_lib4(), 1);
+// node_modules/@tscircuit/ti-parts-engine/lib/kicad-archive/readFirstKicadLibraryFilesFromArchive.ts
+var import_jszip7 = __toESM2(require_lib4(), 1);
+// node_modules/@tscircuit/ti-parts-engine/lib/kicad-archive/readFirstKicadModFromArchive.ts
+var import_jszip8 = __toESM2(require_lib4(), 1);
+// node_modules/@tscircuit/ti-parts-engine/lib/ultra-librarian-bridge-client/normalizeBaseUrl.ts
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.replace(/\/+$/, "");
+}
+
+// node_modules/@tscircuit/ti-parts-engine/lib/ultra-librarian-bridge-client/types.ts
+var DEFAULT_BASE_URL = "https://ti-api-cors-proxy.seve.workers.dev/";
+var DEFAULT_KICAD_VERSION = 6;
+
+// node_modules/@tscircuit/ti-parts-engine/lib/ultra-librarian-bridge-client/paths.ts
+function buildSearchPath(request) {
+  const query = requireNonEmptyString("query", request.query);
+  const exactOnly = request.exactOnly ?? true;
+  const limit = request.limit ?? 1;
+  assertPositiveInteger("limit", limit);
+  const params2 = new URLSearchParams({
+    q: query,
+    exact_only: String(exactOnly),
+    limit: String(limit)
+  });
+  return `/v1/parts/search?${params2.toString()}`;
+}
+function buildKicadExportPath(request) {
+  const mpn = requireNonEmptyString("mpn", request.mpn);
+  const version2 = request.version ?? DEFAULT_KICAD_VERSION;
+  assertPositiveInteger("version", version2);
+  const params2 = new URLSearchParams({
+    mpn,
+    version: String(version2)
+  });
+  return `/v1/export/kicad?${params2.toString()}`;
+}
+function requireNonEmptyString(name, value) {
+  const trimmedValue = value.trim();
+  if (trimmedValue.length === 0) {
+    throw new Error(`${name} is required.`);
+  }
+  return trimmedValue;
+}
+function assertPositiveInteger(name, value) {
+  if (!Number.isInteger(value) || value < 1) {
+    throw new Error(`${name} must be a positive integer.`);
+  }
+}
+
+// node_modules/@tscircuit/ti-parts-engine/lib/ultra-librarian-bridge-client/createDefaultBridgeFetch.ts
+var createDefaultBridgeFetch = () => {
+  return async (input, init2) => {
+    const targetUrl = input.toString();
+    const proxyEndpointUrl = getTscircuitProxyEndpointUrl(targetUrl);
+    if (!proxyEndpointUrl) {
+      return globalThis.fetch(input, init2);
+    }
+    const headers = new Headers(init2?.headers);
+    headers.set("X-Target-Url", targetUrl);
+    const targetOrigin = safeGetOrigin(targetUrl);
+    if (targetOrigin) {
+      headers.set("X-Sender-Origin", targetOrigin);
+    }
+    return globalThis.fetch(proxyEndpointUrl, {
+      ...init2,
+      headers
+    });
+  };
+};
+function getTscircuitProxyEndpointUrl(targetUrl) {
+  if (typeof window === "undefined" || !window.location) {
+    return null;
+  }
+  const targetOrigin = safeGetOrigin(targetUrl);
+  const currentOrigin = window.location.origin;
+  if (!targetOrigin || targetOrigin === currentOrigin) {
+    return null;
+  }
+  if (window.TSCIRCUIT_FILESERVER_API_BASE_URL) {
+    return `${window.TSCIRCUIT_FILESERVER_API_BASE_URL.replace(/\/+$/, "")}/proxy`;
+  }
+  if (isLocalHttpOrigin(currentOrigin)) {
+    return `${currentOrigin}/proxy`;
+  }
+  return null;
+}
+function safeGetOrigin(url2) {
+  try {
+    return new URL(url2).origin;
+  } catch {
+    return null;
+  }
+}
+function isLocalHttpOrigin(origin) {
+  try {
+    const url2 = new URL(origin);
+    return (url2.protocol === "http:" || url2.protocol === "https:") && (url2.hostname === "localhost" || url2.hostname === "127.0.0.1" || url2.hostname === "::1");
+  } catch {
+    return false;
+  }
+}
 
+// node_modules/@tscircuit/ti-parts-engine/lib/ultra-librarian-bridge-client/requestArchive.ts
+async function requestArchive(options) {
+  const url2 = buildRequestUrl(options.baseUrl, options.path);
+  logRequest(options.logger, url2);
+  const response = await options.fetchImpl(url2, {
+    headers: createBridgeHeaders(options.partnerToken, "application/zip"),
+    redirect: "follow"
+  });
+  if (!response.ok) {
+    throw new Error(`KiCad export failed with ${response.status} ${response.statusText}: ${await readErrorBody(response)}`);
+  }
+  const contentType = response.headers.get("content-type") ?? "unknown";
+  if (!contentType.includes("application/zip") && !contentType.includes("application/octet-stream")) {
+    throw new Error(`Expected application/zip but received ${contentType}.`);
+  }
+  return {
+    archiveBuffer: await response.arrayBuffer(),
+    contentType
+  };
+}
+function createBridgeHeaders(partnerToken, accept) {
+  const headers = {
+    Accept: accept
+  };
+  if (partnerToken) {
+    headers.Authorization = `Bearer ${partnerToken}`;
+  }
+  return headers;
+}
+function buildRequestUrl(baseUrl, path67) {
+  return `${normalizeBaseUrl(baseUrl)}${path67}`;
+}
+function logRequest(logger, url2) {
+  if (!logger)
+    return;
+  const requestUrl = new URL(url2);
+  logger.log(`GET ${requestUrl.pathname}${requestUrl.search}`);
+}
+async function readErrorBody(response) {
+  const bodyText = (await response.text()).trim();
+  return bodyText.length > 0 ? bodyText : "<empty response body>";
+}
+
+// node_modules/@tscircuit/ti-parts-engine/lib/ultra-librarian-bridge-client/requestJson.ts
+async function requestJson(options) {
+  const url2 = buildRequestUrl2(options.baseUrl, options.path);
+  logRequest2(options.logger, url2);
+  const response = await options.fetchImpl(url2, {
+    headers: createBridgeHeaders2(options.partnerToken, "application/json")
+  });
+  if (!response.ok) {
+    throw new Error(`Search request failed with ${response.status} ${response.statusText}: ${await readErrorBody2(response)}`);
+  }
+  return asJsonValue(await response.json());
+}
+function createBridgeHeaders2(partnerToken, accept) {
+  const headers = {
+    Accept: accept
+  };
+  if (partnerToken) {
+    headers.Authorization = `Bearer ${partnerToken}`;
+  }
+  return headers;
+}
+function buildRequestUrl2(baseUrl, path67) {
+  return `${normalizeBaseUrl(baseUrl)}${path67}`;
+}
+function logRequest2(logger, url2) {
+  if (!logger)
+    return;
+  const requestUrl = new URL(url2);
+  logger.log(`GET ${requestUrl.pathname}${requestUrl.search}`);
+}
+async function readErrorBody2(response) {
+  const bodyText = (await response.text()).trim();
+  return bodyText.length > 0 ? bodyText : "<empty response body>";
+}
+function asJsonValue(value) {
+  return value;
+}
+
+// node_modules/@tscircuit/ti-parts-engine/lib/ultra-librarian-bridge-client/search-response.ts
+function extractSearchResults(payload) {
+  if (Array.isArray(payload)) {
+    return payload.filter(isSearchPartResult);
+  }
+  if (!isJsonObject(payload)) {
+    return [];
+  }
+  for (const key of ["results", "items", "parts", "data"]) {
+    const value = payload[key];
+    if (Array.isArray(value)) {
+      return value.filter(isSearchPartResult);
+    }
+  }
+  return [];
+}
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSearchPartResult(value) {
+  return isJsonObject(value);
+}
+
+// node_modules/@tscircuit/ti-parts-engine/lib/ultra-librarian-bridge-client/createUltraLibrarianBridgeClient.ts
+function createUltraLibrarianBridgeClient(options = {}) {
+  const partnerToken = normalizeOptionalString(options.partnerToken);
+  const baseUrl = normalizeBaseUrl(options.baseUrl ?? DEFAULT_BASE_URL);
+  const fetchImpl = options.fetch ?? createDefaultBridgeFetch();
+  const logger = options.logger;
+  return {
+    baseUrl,
+    async searchParts(request) {
+      const path67 = buildSearchPath(request);
+      const rawPayload = await requestJson({
+        fetchImpl,
+        baseUrl,
+        path: path67,
+        partnerToken,
+        logger
+      });
+      return {
+        rawPayload,
+        results: extractSearchResults(rawPayload)
+      };
+    },
+    async downloadKicadArchive(request) {
+      const path67 = buildKicadExportPath(request);
+      return await requestArchive({
+        fetchImpl,
+        baseUrl,
+        path: path67,
+        partnerToken,
+        logger
+      });
+    }
+  };
+}
+function normalizeOptionalString(value) {
+  const trimmedValue = value?.trim();
+  return trimmedValue ? trimmedValue : undefined;
+}
+// node_modules/@tscircuit/ti-parts-engine/lib/ti-parts-engine/TiPartsEngine.ts
+class TiPartsEngine {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+    this.searchParts = this.searchParts.bind(this);
+    this.downloadKicadArchive = this.downloadKicadArchive.bind(this);
+    this.findPart = this.findPart.bind(this);
+  }
+  async findPart({ sourceComponent }) {
+    const manufacturerPartNumber = getManufacturerPartNumber(sourceComponent);
+    if (!manufacturerPartNumber) {
+      return {};
+    }
+    const searchResponse = await this.searchParts({
+      query: manufacturerPartNumber,
+      exactOnly: true,
+      limit: 1
+    });
+    const matchingPart = searchResponse.results[0];
+    if (!matchingPart) {
+      return {};
+    }
+    const resolvedPartNumber = matchingPart?.mpn ?? matchingPart?.manufacturer_part_number ?? matchingPart?.part_number ?? matchingPart?.gpn ?? manufacturerPartNumber;
+    return {
+      ti: [resolvedPartNumber]
+    };
+  }
+  async searchParts(request) {
+    return await this.createClient().searchParts(request);
+  }
+  async downloadKicadArchive(request) {
+    return await this.createClient().downloadKicadArchive(request);
+  }
+  createClient() {
+    return createUltraLibrarianBridgeClient(this.options);
+  }
+}
+function getManufacturerPartNumber(sourceComponent) {
+  if (!isRecord2(sourceComponent)) {
+    return null;
+  }
+  const value = sourceComponent.manufacturer_part_number;
+  return typeof value === "string" && value.trim() ? value : null;
+}
+function isRecord2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+// node_modules/@tscircuit/ti-parts-engine/lib/ti-parts-engine/createTiFootprintLibrary.ts
+import {
+  KicadFootprintToCircuitJsonConverter,
+  KicadSymbolToCircuitJsonConverter
+} from "kicad-to-circuit-json";
 // cli/search/register.ts
 var registerSearch = (program3) => {
-  program3.command("search").description("Search for footprints, CAD models or packages in the tscircuit ecosystem").argument("<query...>", "Search query (e.g. keyword, author, or package name)").option("--kicad", "Search KiCad footprints").option("--jlcpcb", "Search JLCPCB components").option("--lcsc", "Alias for --jlcpcb").option("--tscircuit", "Search tscircuit registry packages").option("--json", "Output search results as JSON").action(async (queryParts, opts) => {
+  program3.command("search").description("Search for footprints, CAD models or packages in the tscircuit ecosystem").argument("<query...>", "Search query (e.g. keyword, author, or package name)").option("--kicad", "Search KiCad footprints").option("--jlcpcb", "Search JLCPCB components").option("--lcsc", "Alias for --jlcpcb").option("--ti", "Search Texas Instruments components").option("--tscircuit", "Search tscircuit registry packages").option("--json", "Output search results as JSON").action(async (queryParts, opts) => {
     const query = getQueryFromParts(queryParts);
-    const hasFilters = opts.kicad || opts.jlcpcb || opts.lcsc || opts.tscircuit;
+    const hasFilters = opts.kicad || opts.jlcpcb || opts.lcsc || opts.ti || opts.tscircuit;
     const searchKicad = opts.kicad;
     const searchJlc = opts.jlcpcb || opts.lcsc || !hasFilters;
+    const searchTi = opts.ti;
     const searchTscircuit = opts.tscircuit;
     let results = { packages: [] };
     let jlcResults = [];
+    let tiResults = [];
     let kicadResults = [];
     try {
       if (searchTscircuit) {
@@ -277354,6 +277757,17 @@ var registerSearch = (program3) => {
         const jlcResponse = await fetch(jlcSearchUrl).then((r4) => r4.json());
         jlcResults = jlcResponse?.components ?? [];
       }
+      if (searchTi) {
+        const tiPartsEngine = new TiPartsEngine({
+          baseUrl: process.env.TSCIRCUIT_TI_API_BASE_URL
+        });
+        const tiResponse = await tiPartsEngine.searchParts({
+          query,
+          exactOnly: false,
+          limit: 10
+        });
+        tiResults = tiResponse.results;
+      }
       if (searchKicad) {
         const kicadFiles = await fetch("https://kicad-mod-cache.tscircuit.com/kicad_files.json").then((r4) => r4.json());
         const fuse = new entry_default(kicadFiles);
@@ -277376,6 +277790,10 @@ var registerSearch = (program3) => {
         ...jlcResults.map((comp) => ({
           source: "jlcpcb",
           ...comp
+        })),
+        ...tiResults.map((part) => ({
+          source: "ti",
+          ...part
         }))
       ];
       console.log(JSON.stringify({
@@ -277384,10 +277802,11 @@ var registerSearch = (program3) => {
       }, null, 2));
       return;
     }
-    if (!kicadResults.length && !results.packages.length && !jlcResults.length) {
+    if (!kicadResults.length && !results.packages.length && !jlcResults.length && !tiResults.length) {
       const sources = [
         searchTscircuit && "tscircuit registry",
         searchJlc && "JLCPCB",
+        searchTi && "Texas Instruments",
         searchKicad && "KiCad"
       ].filter(Boolean);
       console.log(kleur_default.yellow(`No results found for "${query}" in ${sources.join(", ")}.`));
@@ -277414,6 +277833,19 @@ var registerSearch = (program3) => {
         console.log(`${idx + 1}. ${comp.mfr} (C${comp.lcsc}) - ${comp.description} (stock: ${comp.stock.toLocaleString("en-US")})`);
       });
     }
+    if (tiResults.length) {
+      console.log(kleur_default.bold().underline(`Found ${tiResults.length} component(s) from Texas Instruments:`));
+      tiResults.forEach((part, idx) => {
+        const mpn = part.mpn ?? part.manufacturer_part_number ?? part.name ?? "?";
+        const assets = [
+          part.symbol_available === true && "symbol",
+          part.footprint_available === true && "footprint",
+          part.threed_available === true && "3D model"
+        ].filter(Boolean);
+        const assetStr = assets.length ? ` - ${assets.join(", ")} available` : "";
+        console.log(`${idx + 1}. ${mpn}${assetStr}`);
+      });
+    }
     console.log(`
 `);
   });