bsmnt 0.2.7 → 0.2.9

package/src/helpers/integrate/sanity/files/app/sitemap.md/route.ts

@@ -0,0 +1,82 @@
+import { NextResponse } from "next/server";
+import { isSanityConfigured } from "@/lib/integrations/check-integration";
+
+export async function GET() {
+	const baseUrl = process.env.NEXT_PUBLIC_BASE_URL || "http://localhost:3000";
+
+	if (!isSanityConfigured()) {
+		return new NextResponse(
+			"# Sitemap\n\nCMS not configured. No content available.",
+			{
+				headers: { "Content-Type": "text/markdown; charset=utf-8" },
+			},
+		);
+	}
+
+	try {
+		const sanityModule = await import("@/lib/integrations/sanity/client");
+		const sanityGroq = await import("next-sanity");
+
+		const client = sanityModule?.client;
+		const groq = sanityGroq?.groq;
+
+		if (!(client && groq)) {
+			return new NextResponse("# Sitemap\n\nUnable to connect to CMS.", {
+				status: 503,
+				headers: { "Content-Type": "text/markdown; charset=utf-8" },
+			});
+		}
+
+		type SanityDoc = {
+			title: string;
+			slug: { current: string };
+			_updatedAt: string;
+		};
+
+		const articles = await client.fetch<SanityDoc[]>(
+			groq`*[_type == "article" && defined(slug.current)] | order(publishedAt desc) {
+					title,
+					slug,
+					_updatedAt
+				}`,
+		);
+
+		const parts = [
+			`# ${new URL(baseUrl).hostname} - Content Sitemap`,
+			"",
+			"> This sitemap lists all content available in markdown format for AI agents.",
+			"> Access any link below directly, or request page URLs with `Accept: text/markdown` header.",
+			"",
+		];
+
+		if (articles.length > 0) {
+			parts.push("## Articles", "");
+			for (const article of articles) {
+				parts.push(
+					`- [${article.title}](${baseUrl}/blog/${article.slug.current}.md)`,
+				);
+			}
+			parts.push("");
+		}
+
+		if (articles.length === 0) {
+			parts.push("No content published yet.", "");
+		}
+
+		const markdown = parts.join("\n");
+
+		return new NextResponse(markdown, {
+			headers: {
+				"Content-Type": "text/markdown; charset=utf-8",
+				"X-Content-Type-Options": "nosniff",
+				"Cache-Control": "public, s-maxage=3600, stale-while-revalidate=600",
+			},
+		});
+	} catch (error) {
+		console.error("Error generating sitemap.md:", error);
+		return new NextResponse("# Sitemap\n\nError fetching content.", {
+			status: 500,
+			headers: { "Content-Type": "text/markdown; charset=utf-8" },
+		});
+	}
+}

package/src/helpers/integrate/sanity/files/app/sitemap.ts

@@ -14,7 +14,7 @@ export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
 		},
 	];
 
-	// Only fetch Sanity pages if Sanity is configured
+	// Only fetch Sanity articles if Sanity is configured
 	if (isSanityConfigured()) {
 		try {
 			const sanityModule = await import("@/lib/integrations/sanity/client");
@@ -32,15 +32,6 @@ export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
 				metadata?: { noIndex?: boolean };
 			};
 
-			// Fetch all published pages and articles
-			const pages = (await client.fetch(
-				groq`*[_type == "page" && defined(slug.current)] {
-          slug,
-          _updatedAt,
-          metadata
-        }`,
-			)) as SanityDocument[];
-
 			const articles = (await client.fetch(
 				groq`*[_type == "article" && defined(slug.current)] {
           slug,
@@ -49,16 +40,6 @@ export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
         }`,
 			)) as SanityDocument[];
 
-			// Add pages to sitemap (exclude noIndex pages)
-			const pageEntries: MetadataRoute.Sitemap = pages
-				.filter((page: SanityDocument) => !page.metadata?.noIndex)
-				.map((page: SanityDocument) => ({
-					url: `${APP_BASE_URL}/${page.slug.current}`,
-					lastModified: new Date(page._updatedAt),
-					changeFrequency: "weekly" as const,
-					priority: 0.8,
-				}));
-
 			// Add articles to sitemap (exclude noIndex articles)
 			const articleEntries: MetadataRoute.Sitemap = articles
 				.filter((article: SanityDocument) => !article.metadata?.noIndex)
@@ -69,7 +50,7 @@ export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
 					priority: 0.7,
 				}));
 
-			return [...baseRoutes, ...pageEntries, ...articleEntries];
+			return [...baseRoutes, ...articleEntries];
 		} catch (error) {
 			console.error("Error generating sitemap from Sanity:", error);
 			return baseRoutes;

package/src/helpers/integrate/sanity/files/lib/integrations/README.md

@@ -34,7 +34,7 @@ NEXT_PUBLIC_GOOGLE_ANALYTICS=G-XXXXXXXXXX
 // Sanity
 import { sanityFetch } from '@/integrations/sanity/live'
 import { RichText } from '@/integrations/sanity/components/rich-text'
-const { data } = await sanityFetch({ query: pageQuery })
+const { data } = await sanityFetch({ query: ARTICLE_QUERY })
 
 // Shopify
 import { Cart, AddToCart } from '@/lib/integrations/shopify/cart'

package/src/helpers/integrate/sanity/files/lib/integrations/sanity/MARKDOWN-PROXY.md

@@ -0,0 +1,273 @@
+# Markdown Proxy — Adding New Content Types
+
+This project serves Sanity content as markdown for AI agents. Each content type (article, etc.) has a dedicated route handler that fetches from Sanity and returns formatted markdown.
+
+## Architecture Overview
+
+```
+Request: GET /blog/my-post.md
+    |
+proxy.ts — rewrites to /api/blog/my-post.md
+    |
+app/api/blog/[slug]/route.ts — validates .md extension, strips it, fetches from Sanity, returns markdown
+```
+
+Route handlers live under `/api/` so `page.tsx` can coexist at the public path (e.g. `app/blog/[slug]/page.tsx` for the HTML page). The `proxy.ts` file rewrites `.md` URLs to the API routes transparently.
+
+**Key files:**
+
+| File | Purpose |
+|------|---------|
+| `app/api/{type}/[slug]/route.ts` | API route handler per content type (serves markdown) |
+| `app/sitemap.md/route.ts` | Discovery endpoint listing all markdown content |
+| `proxy.ts` | Rewrites `.md` URLs to API routes, handles `Accept: text/markdown` |
+| `lib/integrations/sanity/markdown-proxy.config.ts` | Route config for proxy rewrites |
+| `lib/integrations/sanity/utils/link.ts` | `CONTENT_TYPE_TO_PATH` mapping for internal link resolution |
+| `lib/integrations/sanity/queries.ts` | GROQ queries for each content type |
+| `lib/utils/portable-text-to-markdown.ts` | Shared Portable Text to markdown converter |
+| `lib/integrations/sanity/live/index.tsx` | `SanityFetch` helper for markdown routes |
+
+**Access patterns:**
+
+1. **Direct URL**: `GET /blog/my-post.md` — proxy rewrites to `/api/blog/my-post.md`, route handler validates `.md`, strips it, serves markdown
+2. **Accept header**: `GET /blog/my-post` with `Accept: text/markdown` — proxy rewrites to `/api/blog/my-post.md`
+3. **Without `.md`**: `GET /blog/my-post` — serves the HTML page (if `page.tsx` exists), not markdown
+4. **Discovery**: `GET /sitemap.md` — lists all available markdown content
+
+## Step-by-Step: Add a New Content Type
+
+Example: adding a `blog` content type backed by Sanity document type `blog`.
+
+### 1. Check your Sanity schema
+
+Look at your schema definition in `lib/integrations/sanity/schemas/` to understand the fields. Every field you want in the markdown output needs to be queried and rendered.
+
+### 2. Add a GROQ query
+
+In `lib/integrations/sanity/queries.ts`:
+
+```ts
+export const BLOG_QUERY = defineQuery(`
+  *[_type == "blog" && slug.current == $slug][0] {
+    _id,
+    title,
+    slug,
+    excerpt,
+    author,
+    publishedAt,
+    ${richTextWithLinks},
+    tags,
+    metadata,
+    _updatedAt
+  }
+`;
+```
+
+Rules:
+- Always include `_id`, `title`, `slug`, `_updatedAt`
+- Use the existing `richTextWithLinks` fragment for any `content` field with Portable Text — it resolves internal links within rich text markup
+- Use `$slug` parameter — `SanityFetch` passes it automatically
+- Include all fields you want to render in the markdown output
+
+### 3. Create the route handler
+
+Create `app/api/blog/[slug]/route.ts`:
+
+```ts
+import { NextResponse } from "next/server";
+import { portableTextToMarkdown } from "@/lib/utils/portable-text-to-markdown";
+import { isSanityConfigured } from "@/lib/integrations/check-integration";
+import { BLOG_QUERY } from "@/lib/integrations/sanity/queries";
+import { SanityFetch } from "@/lib/integrations/sanity/live";
+
+export async function GET(
+  _request: Request,
+  props: { params: Promise<{ slug: string }> },
+) {
+  const { slug: rawSlug } = await props.params;
+
+  if (!rawSlug.endsWith(".md")) {
+    return new NextResponse(null, { status: 404 });
+  }
+
+  const slug = rawSlug.slice(0, -3);
+  const baseUrl = process.env.NEXT_PUBLIC_BASE_URL || "http://localhost:3000";
+
+  if (!isSanityConfigured()) {
+    return new NextResponse("# 404 Not Found\n\nCMS not configured.", {
+      status: 404,
+      headers: { "Content-Type": "text/markdown; charset=utf-8" },
+    });
+  }
+
+  try {
+    const blog = await SanityFetch(slug, BLOG_QUERY, "Blog Post");
+
+    // SanityFetch returns NextResponse on error — pass it through
+    if (blog instanceof NextResponse) return blog;
+
+    const parts: (string | null)[] = [
+      `# ${blog.title}`,
+      "",
+      blog.excerpt ? `> ${blog.excerpt}` : null,
+      "",
+      blog.author ? `**Author:** ${blog.author}` : null,
+      blog.publishedAt
+        ? `**Published:** ${new Date(blog.publishedAt).toLocaleDateString()}`
+        : null,
+      blog._updatedAt
+        ? `**Updated:** ${new Date(blog._updatedAt).toLocaleDateString()}`
+        : null,
+      blog.tags?.length ? `**Tags:** ${blog.tags.join(", ")}` : null,
+      "",
+      "---",
+      "",
+      portableTextToMarkdown(blog.content),
+      "",
+      "---",
+      "",
+      `[View all content](${baseUrl}/sitemap.md)`,
+    ];
+
+    const markdown = parts.filter((part) => part !== null).join("\n");
+
+    return new NextResponse(markdown, {
+      headers: {
+        "Content-Type": "text/markdown; charset=utf-8",
+        Vary: "Accept",
+        "X-Content-Type-Options": "nosniff",
+      },
+    });
+  } catch (error) {
+    console.error("Error fetching blog markdown:", error);
+    return new NextResponse("# 500 Error\n\nFailed to fetch blog post.", {
+      status: 500,
+      headers: { "Content-Type": "text/markdown; charset=utf-8" },
+    });
+  }
+}
+```
+
+**Route handler rules:**
+
+- Always validate `rawSlug.endsWith(".md")` first — return 404 if missing
+- Strip `.md` with `rawSlug.slice(0, -3)` to get the actual slug
+- Check `isSanityConfigured()` before querying
+- Use `SanityFetch(slug, query, label)` — it handles 404/500/503 errors
+- Check `if (result instanceof NextResponse) return result` to propagate error responses
+- Use `portableTextToMarkdown()` for any Portable Text / rich text field
+- Include a link to `/sitemap.md` at the bottom
+- Set `Content-Type: text/markdown; charset=utf-8` on all responses
+- Map **every schema field** to markdown — dates formatted, arrays joined, booleans as text
+
+### 4. Update the link resolver
+
+In `lib/integrations/sanity/utils/link.ts`, add the new type to `CONTENT_TYPE_TO_PATH`:
+
+```ts
+export const CONTENT_TYPE_TO_PATH: Record<string, string> = {
+  article: "/blog",
+  blog: "/blog",       // add this
+};
+```
+
+This ensures `resolveMarkdownUrl` generates correct `.md` links when other content types reference blog posts via internal links.
+
+### 5. Update the sitemap
+
+In `app/sitemap.md/route.ts`, add a query and section for the new type:
+
+```ts
+// In the fetch block, add:
+const [articles, blogs] = await Promise.all([
+  // ... existing queries ...
+  client.fetch<SanityDoc[]>(
+    groq`*[_type == "blog" && defined(slug.current)] | order(publishedAt desc) {
+      title,
+      slug,
+      _updatedAt
+    }`,
+  ),
+]);
+
+// After the existing sections, add:
+if (blogs.length > 0) {
+  parts.push("## Blog Posts", "");
+  for (const blog of blogs) {
+    parts.push(
+      `- [${blog.title}](${baseUrl}/blog/${blog.slug.current}.md)`,
+    );
+  }
+  parts.push("");
+}
+```
+
+## Field to Markdown Mapping
+
+| Schema Field Type | Markdown Output |
+|---|---|
+| `string` (title) | `# ${value}` |
+| `text` (excerpt) | `> ${value}` |
+| `string` (author) | `**Author:** ${value}` |
+| `datetime` | `**Published:** ${new Date(value).toLocaleDateString()}` |
+| `array of strings` (tags) | `**Tags:** ${value.join(", ")}` |
+| `array of blocks` (content) | `portableTextToMarkdown(value)` |
+| `image` | Handled automatically inside `portableTextToMarkdown` |
+| `reference` (internal link) | `[${text}](resolveMarkdownUrl(ref, baseUrl))` |
+| `url` (external link) | `[${text}](${url})` |
+| `slug` | Not rendered directly — used for routing |
+| `object` (metadata) | Not rendered — used for SEO only |
+
+## Markdown Structure Convention
+
+Every route handler should produce this structure:
+
+```markdown
+# Title
+
+**Field:** value
+**Field:** value
+
+---
+
+[main content from Portable Text]
+
+---
+
+[View all content](baseUrl/sitemap.md)
+```
+
+- Title as `h1`
+- Metadata fields as bold key-value pairs
+- Horizontal rules to separate metadata from content
+- Footer link back to sitemap for navigation
+
+## SanityFetch Helper
+
+The `SanityFetch` function in `lib/integrations/sanity/live/index.tsx` wraps `sanityFetch` with standardized markdown error handling:
+
+```ts
+const result = await SanityFetch(slug, yourQuery, "Label");
+if (result instanceof NextResponse) return result; // Error response (404, 500, 503)
+// result is now your data
+```
+
+It returns:
+- **503** — CMS client unavailable
+- **404** — Document not found (null data)
+- **500** — Query execution error
+- **Data** — The fetched document on success
+
+## Checklist
+
+When adding a new content type, verify all of these:
+
+- [ ] GROQ query in `queries.ts` fetches all schema fields
+- [ ] Route handler at `app/api/{type}/[slug]/route.ts` with `.md` extension validation
+- [ ] Route added to `markdown-proxy.config.ts` (`mdExtensionRoutes`)
+- [ ] `CONTENT_TYPE_TO_PATH` updated in `utils/link.ts`
+- [ ] Sitemap section added in `app/sitemap.md/route.ts`
+- [ ] Test: `curl http://localhost:3000/{type}/{slug}.md` returns markdown
+- [ ] Test: `curl http://localhost:3000/sitemap.md` lists the new content
+- [ ] Test: `curl http://localhost:3000/{type}/nonexistent.md` returns 404
+- [ ] Test: `curl http://localhost:3000/{type}/{slug}` returns 404 (no `.md` = no markdown)

package/src/helpers/integrate/sanity/files/lib/integrations/sanity/README.md

@@ -22,7 +22,7 @@ NEXT_PUBLIC_SANITY_API_VERSION="2024-03-15"
 ## Quick Start
 
 1. Access Studio at `/studio`
-2. Create content (Pages, Articles)
+2. Create content (Articles)
 3. Click "Present" for visual editing
 
 ## Usage
@@ -31,12 +31,12 @@ NEXT_PUBLIC_SANITY_API_VERSION="2024-03-15"
 
 ```tsx
 import { sanityFetch } from 'next-sanity/live'
-import { pageQuery } from '@/lib/integrations/sanity/queries'
+import { ARTICLE_QUERY } from '@/lib/integrations/sanity/queries'
 
 export default async function Page({ params }) {
-  const { data } = await sanityFetch({ 
-    query: pageQuery, 
-    params: { slug: params.slug } 
+  const { data } = await sanityFetch({
+    query: ARTICLE_QUERY,
+    params: { slug: params.slug }
   })
   return <YourComponent data={data} />
 }
@@ -48,11 +48,11 @@ For `generateStaticParams` or other build-time functions, use the client directl
 
 ```tsx
 import { client } from '@/lib/integrations/sanity/client'
-import { allArticlesQuery } from '@/lib/integrations/sanity/queries'
+import { ALL_ARTICLES_QUERY } from '@/lib/integrations/sanity/queries'
 
 export async function generateStaticParams() {
   if (!client) return []
-  const data = await client.fetch(allArticlesQuery)
+  const data = await client.fetch(ALL_ARTICLES_QUERY)
   return data.map((item) => ({ slug: item.slug?.current ?? '' }))
 }
 ```
@@ -93,8 +93,8 @@ import { SanityImage } from '@/components/ui/sanity-image'
 import { generateSanityMetadata } from '@/lib/utils/metadata'
 
 export async function generateMetadata({ params }) {
-  const { data } = await sanityFetch({ query: pageQuery, params })
-  return generateSanityMetadata({ document: data, url: `/page/${params.slug}` })
+  const { data } = await sanityFetch({ query: ARTICLE_QUERY, params })
+  return generateSanityMetadata({ document: data, url: `/blog/${params.slug}` })
 }
 ```
 

package/src/helpers/integrate/sanity/files/lib/integrations/sanity/components/rich-text.tsx

@@ -1,9 +1,9 @@
-import { PortableText, type PortableTextBlock } from "@portabletext/react";
+import { PortableText, type PortableTextProps } from "@portabletext/react";
 import { Link } from "@/components/ui/link";
 import { SanityImage } from "@/components/ui/sanity-image";
 
 interface RichTextProps {
-	content: PortableTextBlock[];
+	content: PortableTextProps["value"];
 }
 
 interface LinkFieldData {

package/src/helpers/integrate/sanity/files/lib/integrations/sanity/live/index.tsx

@@ -1,4 +1,5 @@
 import { defineLive } from "next-sanity/live";
+import { NextResponse } from "next/server";
 import { isSanityConfigured } from "@/lib/integrations/check-integration";
 import { client } from "../client";
 import { sanityToken } from "../env";
@@ -11,14 +12,14 @@ import { sanityToken } from "../env";
  */
 const isConfigured = isSanityConfigured() && client;
 
-const liveExports = isConfigured
-	? defineLive({
-			// biome-ignore lint/style/noNonNullAssertion: client is checked via isConfigured above
-			client: client!,
-			browserToken: sanityToken,
-			serverToken: sanityToken,
-		})
-	: null;
+const liveExports =
+	isConfigured && client
+		? defineLive({
+				client,
+				browserToken: sanityToken,
+				serverToken: sanityToken,
+			})
+		: null;
 
 /**
  * Standard sanityFetch function from next-sanity/live.
@@ -32,3 +33,47 @@ export const sanityFetch =
  * Returns null when Sanity is not configured.
  */
 export const SanityLive = liveExports?.SanityLive ?? (() => null);
+
+/**
+ * Custom SanityFetch helper for Markdown routes.
+ * Returns the data or a NextResponse with an error message.
+ */
+export const SanityFetch = async <T,>(
+	slug: string,
+	query: string,
+	label = "Content",
+): Promise<T | NextResponse> => {
+	if (!client) {
+		return new NextResponse(`# 503 Unavailable\n\nCMS client unavailable.`, {
+			status: 503,
+			headers: { "Content-Type": "text/markdown; charset=utf-8" },
+		});
+	}
+
+	try {
+		const { data } = await sanityFetch({
+			query,
+			params: { slug },
+		});
+
+		const result = data as T | null;
+
+		if (!result) {
+			return new NextResponse(`# 404 Not Found\n\n${label} not found.`, {
+				status: 404,
+				headers: { "Content-Type": "text/markdown; charset=utf-8" },
+			});
+		}
+
+		return result;
+	} catch (error) {
+		console.error(`Error fetching ${label.toLowerCase()}:`, error);
+		return new NextResponse(
+			`# 500 Error\n\nFailed to fetch ${label.toLowerCase()}.`,
+			{
+				status: 500,
+				headers: { "Content-Type": "text/markdown; charset=utf-8" },
+			},
+		);
+	}
+};

package/src/helpers/integrate/sanity/files/lib/integrations/sanity/markdown-proxy.config.ts

@@ -0,0 +1,49 @@
+export interface MarkdownRoute {
+	/** Regex to match the public-facing URL */
+	regex: RegExp;
+	/** API route path template (under /api/) */
+	apiPath: string;
+	/** Public markdown URL template (for Link headers) */
+	publicPath: string;
+}
+
+/**
+ * Routes that serve markdown versions for AI agents.
+ * Add entries here to enable markdown proxy for new content types.
+ *
+ * How it works:
+ * - `regex`: match the public-facing URL (e.g. /blog/slug.md or /about)
+ * - `apiPath`: the internal API route that serves the markdown (e.g. /api/blog/slug.md)
+ * - Proxy rewrites .md URLs and Accept: text/markdown requests to the API route
+ * - Route handlers live under /api/ so page.tsx can coexist at the public path
+ */
+
+/** .md extension routes — rewrite to API endpoints */
+export const mdExtensionRoutes: MarkdownRoute[] = [
+	{
+		regex: /^\/blog\/([^/]+)\.md$/,
+		apiPath: "/api/blog/[slug].md",
+		publicPath: "/blog/[slug].md",
+	},
+];
+
+/** Accept: text/markdown routes — content negotiation for HTML pages */
+export const acceptHeaderRoutes: MarkdownRoute[] = [
+	{
+		regex: /^\/blog\/([^/.]+)$/,
+		apiPath: "/api/blog/[slug].md",
+		publicPath: "/blog/[slug].md",
+	},
+];
+
+/**
+ * Paths the proxy should never process.
+ * Studio, static files, Next.js internals.
+ */
+export const ignoredPaths = [
+	"/studio",
+	"/api/",
+	"/_next/",
+	"/favicon.ico",
+	"/sitemap.md",
+];

package/src/helpers/integrate/sanity/files/lib/integrations/sanity/queries.ts

@@ -1,4 +1,4 @@
-import { groq } from "next-sanity";
+import { defineQuery } from "next-sanity";
 
 // Helper for rich text content with link projections
 const richTextWithLinks = `
@@ -14,41 +14,8 @@ const richTextWithLinks = `
   }
 `;
 
-const linkWithLabel = `
-  link {
-    ...,
-    internalLink->{_type, slug, title}
-  }
-`;
-
-// Page queries
-export const pageQuery = groq`
-  *[_type == "page" && slug.current == $slug][0] {
-    _id,
-    title,
-    slug,
-    ${richTextWithLinks},
-    ${linkWithLabel},
-    metadata,
-    publishedAt,
-    _updatedAt
-  }
-`;
-
-export const pageByIdQuery = groq`
-  *[_type == "page" && _id == $id][0] {
-    _id,
-    title,
-    slug,
-    ${richTextWithLinks},
-    metadata,
-    publishedAt,
-    _updatedAt
-  }
-`;
-
 // Article queries
-export const articleQuery = groq`
+export const ARTICLE_QUERY = defineQuery(`
   *[_type == "article" && slug.current == $slug][0] {
     _id,
     title,
@@ -63,9 +30,9 @@ export const articleQuery = groq`
     metadata,
     _updatedAt
   }
-`;
+`);
 
-export const allArticlesQuery = groq`
+export const ALL_ARTICLES_QUERY = defineQuery(`
   *[_type == "article"] | order(publishedAt desc) {
     _id,
     title,
@@ -79,9 +46,9 @@ export const allArticlesQuery = groq`
     metadata,
     _updatedAt
   }
-`;
+`);
 
-export const articleByIdQuery = groq`
+export const ARTICLE_BY_ID_QUERY = defineQuery(`
   *[_type == "article" && _id == $id][0] {
     _id,
     title,
@@ -96,4 +63,4 @@ export const articleByIdQuery = groq`
     metadata,
     _updatedAt
   }
-`;
+`);

package/src/helpers/integrate/sanity/files/lib/integrations/sanity/sanity.cli.ts

@@ -10,6 +10,11 @@ export default defineCliConfig({
 	project: {
 		basePath: "/studio",
 	},
+	typegen: {
+		path: "./queries.ts",
+		schema: "./schema.json",
+		generates: "./sanity.types.ts",
+	},
 	vite: {
 		resolve: {
 			alias: {