ronantakizawa/codereview-bench huggingface dataset:
Repository: withastro/astro
File: packages/astro/src/cli/add/index.ts (TypeScript)

Code before:
}\n`,
	LIT_NPMRC: `\
# Lit libraries are required to be hoisted due to dependency issues.
public-hoist-pattern[]=*lit*
`,
	DB_CONFIG: `\
import { defineDb } from 'astro:db';

// https://astro.build/db/config
export default defineDb({
  tables: {}
});
`,
	DB_SEED: `\
import { db } from 'astro:db';

// https://astro.build/db/seed
export default async function seed() {
	// TODO
}
`,
	CLOUDFLARE_WRANGLER_CONFIG: (name: string) => `\
{
	"main": "dist/_worker.js/index.js",
	"name": ${JSON.stringify(name)},
  "compatibility_date": ${JSON.stringify(new Date().toISOString().slice(0,10))},
	"assets": {
		"binding": "ASSETS",
		"directory": "./dist"
	}
}`,
	CLOUDFLARE_ASSETSIGNORE: `_worker.js\n_routes.json`,
};

const OFFICIAL_ADAPTER_TO_IMPORT_MAP: Record<string, string> = {
	netlify: '@astrojs/netlify',
	vercel: '@astrojs/vercel',
	cloudflare: '@astrojs/cloudflare',
	node: '@astrojs/node',
};

export async function add(names: string[], { flags }: AddOptions) {
	ensureProcessNodeEnv('production');
	applyPolyfill();
	const inlineConfig = flagsToAstroInlineConfig(flags);
	const { userConfig } = await resolveConfig(inlineConfig, 'add');
	telemetry.record(eventCliSession('add', userConfig));
	if (flags.help || names.length === 0) {
		printHelp({
			commandName: 'astro add',
			usage: '[...integrations] [...adapters]',

Review comment (suggestion):
```suggestion
  "compatibility_date": ${JSON.stringify(new Date().toISOString().slice(0,10))},
  "compatibility_flags": [
    "nodejs_compat",
    "global_fetch_strictly_public"
  ],
```

from wrangler cli https://github.com/cloudflare/workers-sdk/blob/ca6c01017ccc39671e8724a6b9a5aa37a5e07e57/packages/create-cloudflare/templates/astro/workers/templates/ts/wrangler.jsonc#L7

Code after:
}\n`,
	LIT_NPMRC: `\
# Lit libraries are required to be hoisted due to dependency issues.
public-hoist-pattern[]=*lit*
`,
	DB_CONFIG: `\
import { defineDb } from 'astro:db';

// https://astro.build/db/config
export default defineDb({
  tables: {}
});
`,
	DB_SEED: `\
import { db } from 'astro:db';

// https://astro.build/db/seed
export default async function seed() {
	// TODO
}
`,
	CLOUDFLARE_WRANGLER_CONFIG: (name: string) => `\
{
	"main": "dist/_worker.js/index.js",
	"name": ${JSON.stringify(name)},
  "compatibility_date": ${JSON.stringify(new Date().toISOString().slice(0,10))},
  "compatibility_flags": [
    "nodejs_compat",
    "global_fetch_strictly_public"
  ],
	"assets": {
		"binding": "ASSETS",
		"directory": "./dist"
	},
	"observability": {
    "enabled": true
  }
}`,
	CLOUDFLARE_ASSETSIGNORE: `_worker.js\n_routes.json`,
};

const OFFICIAL_ADAPTER_TO_IMPORT_MAP: Record<string, string> = {
	netlify: '@astrojs/netlify',
	vercel: '@astrojs/vercel',
	cloudflare: '@astrojs/cloudflare',
	node: '@astrojs/node',
};

export async function add(names: string[], { flags }: AddOptions) {
	ensureProcessNodeEnv('production');
	applyPolyfill();
Repository: withastro/astro
File: packages/astro/src/cli/add/index.ts (TypeScript)

Code before:
`,
	DB_CONFIG: `\
import { defineDb } from 'astro:db';

// https://astro.build/db/config
export default defineDb({
  tables: {}
});
`,
	DB_SEED: `\
import { db } from 'astro:db';

// https://astro.build/db/seed
export default async function seed() {
	// TODO
}
`,
	CLOUDFLARE_WRANGLER_CONFIG: (name: string) => `\
{
	"main": "dist/_worker.js/index.js",
	"name": ${JSON.stringify(name)},
  "compatibility_date": ${JSON.stringify(new Date().toISOString().slice(0,10))},
	"assets": {
		"binding": "ASSETS",
		"directory": "./dist"
	}
}`,
	CLOUDFLARE_ASSETSIGNORE: `_worker.js\n_routes.json`,
};

const OFFICIAL_ADAPTER_TO_IMPORT_MAP: Record<string, string> = {
	netlify: '@astrojs/netlify',
	vercel: '@astrojs/vercel',
	cloudflare: '@astrojs/cloudflare',
	node: '@astrojs/node',
};

export async function add(names: string[], { flags }: AddOptions) {
	ensureProcessNodeEnv('production');
	applyPolyfill();
	const inlineConfig = flagsToAstroInlineConfig(flags);
	const { userConfig } = await resolveConfig(inlineConfig, 'add');
	telemetry.record(eventCliSession('add', userConfig));
	if (flags.help || names.length === 0) {
		printHelp({
			commandName: 'astro add',
			usage: '[...integrations] [...adapters]',
			tables: {
				Flags: [
					['--yes', 'Accept all prompts.'],
					['--help', 'Show this help message.'],

Review comment (suggestion):
```suggestion
	},
	"observability": {
    "enabled": true
  }
```
from wrangler cli and our deploy guide 

https://github.com/cloudflare/workers-sdk/blob/ca6c01017ccc39671e8724a6b9a5aa37a5e07e57/packages/create-cloudflare/templates/astro/workers/templates/ts/wrangler.jsonc#L13C1-L15C5

Code after:
`,
	DB_CONFIG: `\
import { defineDb } from 'astro:db';

// https://astro.build/db/config
export default defineDb({
  tables: {}
});
`,
	DB_SEED: `\
import { db } from 'astro:db';

// https://astro.build/db/seed
export default async function seed() {
	// TODO
}
`,
	CLOUDFLARE_WRANGLER_CONFIG: (name: string) => `\
{
	"main": "dist/_worker.js/index.js",
	"name": ${JSON.stringify(name)},
  "compatibility_date": ${JSON.stringify(new Date().toISOString().slice(0,10))},
  "compatibility_flags": [
    "nodejs_compat",
    "global_fetch_strictly_public"
  ],
	"assets": {
		"binding": "ASSETS",
		"directory": "./dist"
	},
	"observability": {
    "enabled": true
  }
}`,
	CLOUDFLARE_ASSETSIGNORE: `_worker.js\n_routes.json`,
};

const OFFICIAL_ADAPTER_TO_IMPORT_MAP: Record<string, string> = {
	netlify: '@astrojs/netlify',
	vercel: '@astrojs/vercel',
	cloudflare: '@astrojs/cloudflare',
	node: '@astrojs/node',
};

export async function add(names: string[], { flags }: AddOptions) {
	ensureProcessNodeEnv('production');
	applyPolyfill();
	const inlineConfig = flagsToAstroInlineConfig(flags);
	const { userConfig } = await resolveConfig(inlineConfig, 'add');
	telemetry.record(eventCliSession('add', userConfig));
	if (flags.help || names.length === 0) {
Repository: withastro/astro
File: packages/astro/src/core/app/entrypoint.ts (TypeScript)

Code before:
import { renderers } from 'virtual:astro:renderers';
import { routes } from 'virtual:astro:routes';
import { manifest as serializedManifest } from 'virtual:astro:serialized-manifest';
import { App } from './app.js';
import type { BaseApp } from './base.js';
import { DevApp } from './dev/app.js';
import { createConsoleLogger } from './logging.js';
import type { SSRManifest } from './types.js';

const actions = async () => {
	return await import('virtual:astro:actions/entrypoint');
};

const middleware = async () => {
	return await import('virtual:astro:middleware');
};

const manifest: SSRManifest = Object.assign(serializedManifest, {
	renderers,
	actions,
	middleware,
	routes,
});

export function getApp(dev = import.meta.env.DEV): BaseApp {
	if (dev) {
		const logger = createConsoleLogger('debug');
		return new DevApp(manifest, true, logger);
	} else {
		return new App(manifest);
	}
}


Review comment (suggestion):
knitpick
```suggestion
const manifest: SSRManifest = Object.assign(serializedManifest, {
	renderers,
	actions: () => import('virtual:astro:actions/entrypoint'),
	middleware: () => import('virtual:astro:middleware'),
	routes,
});
```

Code after:
import { renderers } from 'virtual:astro:renderers';
import { routes } from 'virtual:astro:routes';
import { manifest as serializedManifest } from 'virtual:astro:serialized-manifest';
import { App } from './app.js';
import type { BaseApp } from './base.js';
import { DevApp } from './dev/app.js';
import { createConsoleLogger } from './logging.js';
import type { SSRManifest } from './types.js';

const manifest: SSRManifest = Object.assign(serializedManifest, {
	renderers,
	actions: () => import('virtual:astro:actions/entrypoint'),
	middleware: () => import('virtual:astro:middleware'),
	routes,
});

export function getApp(dev = import.meta.env.DEV): BaseApp {
	if (dev) {
		const logger = createConsoleLogger('debug');
		return new DevApp(manifest, true, logger);
	} else {
		return new App(manifest);
	}
}
Repository: withastro/astro
File: packages/astro/src/core/middleware/loadMiddleware.ts (TypeScript)

Code before:
import { MiddlewareCantBeLoaded } from '../errors/errors-data.js';
import { AstroError } from '../errors/index.js';
import type { ModuleLoader } from '../module-loader/index.js';
import { MIDDLEWARE_MODULE_ID } from './vite-plugin.js';

/**
 * It accepts a module loader and the astro settings, and it attempts to load the middlewares defined in the configuration.
 *
 * If not middlewares were not set, the function returns an empty array.
 */
export async function loadMiddleware(moduleLoader: ModuleLoader) {
	try {
		return await moduleLoader.import(MIDDLEWARE_MODULE_ID);
	} catch (error: any) {
		const astroError = new AstroError(MiddlewareCantBeLoaded, { cause: error });
		throw astroError;
	}
}


Review comment (bug):
I think this should still import `MIDDLEWARE_MODULE_ID` to let Vite handle the module resolution. I'd be happy to be proved wrong tho

Code after:
import { MiddlewareCantBeLoaded } from '../errors/errors-data.js';
import { AstroError } from '../errors/index.js';
import type { ModuleLoader } from '../module-loader/index.js';
import { MIDDLEWARE_RESOLVED_MODULE_ID } from './vite-plugin.js';

/**
 * It accepts a module loader and the astro settings, and it attempts to load the middlewares defined in the configuration.
 *
 * If not middlewares were not set, the function returns an empty array.
 */
export async function loadMiddleware(moduleLoader: ModuleLoader) {
	try {
		return await moduleLoader.import(MIDDLEWARE_RESOLVED_MODULE_ID);
	} catch (error: any) {
		const astroError = new AstroError(MiddlewareCantBeLoaded, { cause: error });
		throw astroError;
	}
}
Repository: withastro/astro
File: packages/astro/src/assets/fonts/implementations/url-resolver.ts (TypeScript)

Code before:
	assetQueryParams,
}: {
	base: string;
	assetsPrefix: AssetsPrefix;
	assetQueryParams?: URLSearchParams;
}): UrlResolver {
	const resources = new Set<string>();
	return {
		resolve(hash) {
			const prefix = assetsPrefix ? getAssetsPrefix(fileExtension(hash), assetsPrefix) : undefined;
			let url: string;
			if (prefix) {
				resources.add(prefix);
				url = joinPaths(prefix, base, hash);
			} else {
				resources.add("'self'");
				url = prependForwardSlash(joinPaths(base, hash));
			}

			// Append assetQueryParams if available (for adapter-level tracking like skew protection)
			if (assetQueryParams) {
				const assetQueryString = assetQueryParams.toString();
				if (assetQueryString) {
					url += '?' + assetQueryString;
				}
			}

			return url;
		},
		getCspResources() {
			return Array.from(resources);
		},
	};
}


Review comment (suggestion):
```suggestion
export function createBuildUrlResolver({
	base,
	assetsPrefix,
	searchParams,
}: {
	base: string;
	assetsPrefix: AssetsPrefix;
	searchParams: URLSearchParams | undefined;
}): UrlResolver {
	const resources = new Set<string>();
	return {
		resolve(hash) {
			const prefix = assetsPrefix ? getAssetsPrefix(fileExtension(hash), assetsPrefix) : undefined;
			let url: string;
			if (prefix) {
				resources.add(prefix);
				url = joinPaths(prefix, base, hash);
			} else {
				resources.add("'self'");
				url = prependForwardSlash(joinPaths(base, hash));
			}

			// Append searchParams if available (for adapter-level tracking like skew protection)
			if (searchParams) {
				const queryString = searchParams.toString();
				if (queryString) {
					url += `?${queryString}`;
				}
			}
```

Code after:
}: {
	base: string;
	assetsPrefix: AssetsPrefix;
	searchParams: URLSearchParams;
}): UrlResolver {
	const resources = new Set<string>();
	return {
		resolve(hash) {
			const prefix = assetsPrefix ? getAssetsPrefix(fileExtension(hash), assetsPrefix) : undefined;
			let urlPath: string;
			if (prefix) {
				resources.add(prefix);
				urlPath = joinPaths(prefix, base, hash);
			} else {
				resources.add("'self'");
				urlPath = prependForwardSlash(joinPaths(base, hash));
			}

			// Create URL object and append searchParams if available (for adapter-level tracking like skew protection)
			const url = createPlaceholderURL(urlPath);
			searchParams.forEach((value, key) => {
				url.searchParams.set(key, value);
			});

			return stringifyPlaceholderURL(url);
		},
		getCspResources() {
			return Array.from(resources);
		},
	};
}
Repository: withastro/astro
File: packages/astro/src/core/session/vite-plugin.ts (TypeScript)

Code before:
import type { AstroSettings } from '../../types/astro.js';

export const VIRTUAL_SESSION_DRIVER_ID = 'virtual:astro:session-driver';
export const RESOLVED_VIRTUAL_SESSION_DRIVER_ID = '\0' + VIRTUAL_SESSION_DRIVER_ID;

function resolveSessionDriver(driver: string | undefined): string | null {
	if (!driver) {
		return null;
	}
	try {
		if (driver === 'fs') {
			return import.meta.resolve(builtinDrivers.fsLite, import.meta.url);
		}
		if (driver in builtinDrivers) {
			return import.meta.resolve(builtinDrivers[driver as BuiltinDriverName], import.meta.url);
		}
	} catch {
		return null;
	}

	return driver;
}

export function vitePluginSessionDriver({ settings }: { settings: AstroSettings }): VitePlugin {
	return {
		name: '@astro/plugin-session-driver',
		enforce: 'pre',

		resolveId(id) {
			if (id === VIRTUAL_SESSION_DRIVER_ID) {
				return RESOLVED_VIRTUAL_SESSION_DRIVER_ID;
			}
		},

		load(id) {
			if (id === RESOLVED_VIRTUAL_SESSION_DRIVER_ID) {
				const resolvedDriver = resolveSessionDriver(settings.config.session?.driver);

				if (!resolvedDriver) {
					// No driver configured - export null
					// Will error at runtime when session is created (existing behavior)
					return { code: 'export default null;' };
				}

				// Re-export the driver module
				return { code: `export { default } from ${JSON.stringify(resolvedDriver)};` };
			}
		},
	};
}


Review comment (suggestion):
Maybe? We do this in a couple of places
```suggestion
		name: VIRTUAL_SESSION_DRIVER_ID,
```

Code after:
import type { AstroSettings } from '../../types/astro.js';

export const VIRTUAL_SESSION_DRIVER_ID = 'virtual:astro:session-driver';
const RESOLVED_VIRTUAL_SESSION_DRIVER_ID = '\0' + VIRTUAL_SESSION_DRIVER_ID;

export function vitePluginSessionDriver({ settings }: { settings: AstroSettings }): VitePlugin {
	return {
		name: VIRTUAL_SESSION_DRIVER_ID,
		enforce: 'pre',

		async resolveId(id) {
			if (id === VIRTUAL_SESSION_DRIVER_ID) {
				if (settings.config.session) {
					if (settings.config.session.driver === 'fs') {
						return await this.resolve(builtinDrivers.fsLite);
					}
					if (settings.config.session.driver && settings.config.session.driver in builtinDrivers) {
						return await this.resolve(
							builtinDrivers[settings.config.session.driver as BuiltinDriverName],
						);
					}
				} else {
					return RESOLVED_VIRTUAL_SESSION_DRIVER_ID;
				}
			}
		},

		async load(id) {
			if (id === RESOLVED_VIRTUAL_SESSION_DRIVER_ID) {
				return { code: 'export default null;' };
			}
		},
	};
}
Repository: withastro/astro
File: packages/astro/src/vite-plugin-app/createExports.ts (TypeScript)

Code before:
import { renderers } from 'virtual:astro:renderers';
import { routes } from 'virtual:astro:routes';
import { manifest as serializedManifest } from 'virtual:astro:serialized-manifest';
import type { RouteInfo } from '../core/app/types.js';
import { Logger } from '../core/logger/core.js';
import { nodeLogDestination } from '../core/logger/node.js';
import type { ModuleLoader } from '../core/module-loader/index.js';
import type { AstroSettings, RoutesList } from '../types/astro.js';
import type { DevServerController } from '../vite-plugin-astro-server/controller.js';
import { AstroServerApp } from './app.js';

export default async function createExports(
	controller: DevServerController,
	settings: AstroSettings,
	loader: ModuleLoader,
) {
	const logger = new Logger({
		dest: nodeLogDestination,
		level: 'info',
	});
	const routesList: RoutesList = { routes: routes.map((r: RouteInfo) => r.routeData) };

	// Merge renderers into the serialized manifest
	const manifest = Object.assign(serializedManifest, {
		renderers,
		sessionDriver: async () => await import('virtual:astro:session-driver'),
	});

	const app = await AstroServerApp.create(manifest, routesList, logger, loader, settings);
	return {
		handler(incomingRequest: http.IncomingMessage, incomingResponse: http.ServerResponse) {
			app.handleRequest({
				controller,
				incomingRequest,
				incomingResponse,
				isHttps: loader?.isHttps() ?? false,
			});
		},
	};
}


Review comment (suggestion):
```suggestion
		sessionDriver: () => import('virtual:astro:session-driver'),
```

Code after:
import { renderers } from 'virtual:astro:renderers';
import { routes } from 'virtual:astro:routes';
import { manifest as serializedManifest } from 'virtual:astro:serialized-manifest';
import type { RouteInfo } from '../core/app/types.js';
import { Logger } from '../core/logger/core.js';
import { nodeLogDestination } from '../core/logger/node.js';
import type { ModuleLoader } from '../core/module-loader/index.js';
import type { AstroSettings, RoutesList } from '../types/astro.js';
import type { DevServerController } from '../vite-plugin-astro-server/controller.js';
import { AstroServerApp } from './app.js';

export default async function createExports(
	controller: DevServerController,
	settings: AstroSettings,
	loader: ModuleLoader,
) {
	const logger = new Logger({
		dest: nodeLogDestination,
		level: 'info',
	});
	const routesList: RoutesList = { routes: routes.map((r: RouteInfo) => r.routeData) };

	// Merge renderers into the serialized manifest
	const manifest = Object.assign(serializedManifest, {
		renderers,
		sessionDriver: () => import('virtual:astro:session-driver'),
	});

	const app = await AstroServerApp.create(manifest, routesList, logger, loader, settings);
	return {
		handler(incomingRequest: http.IncomingMessage, incomingResponse: http.ServerResponse) {
			app.handleRequest({
				controller,
				incomingRequest,
				incomingResponse,
				isHttps: loader?.isHttps() ?? false,
			});
		},
	};
}
Repository: withastro/astro
File: packages/astro/src/actions/runtime/server.ts (TypeScript)

Code before:
} from './shared.js';
import type { Locals } from './utils.js';
import {
	ACTION_API_CONTEXT_SYMBOL,
	type ActionAPIContext,
	type ErrorInferenceObject,
	formContentTypes,
	hasContentType,
	isActionAPIContext,
	type MaybePromise,
} from './utils.js';

export * from './shared.js';

export type ActionAccept = 'form' | 'json';

export type ActionHandler<TInputSchema, TOutput> = TInputSchema extends z.ZodType
	? (input: z.infer<TInputSchema>, context: ActionAPIContext) => MaybePromise<TOutput>
	: (input: any, context: ActionAPIContext) => MaybePromise<TOutput>;

export type ActionReturnType<T extends ActionHandler<any, any>> = Awaited<ReturnType<T>>;

const inferSymbol = Symbol('#infer');

/**
 * Infer the input zod schema of an action.
 *
 * @see https://docs.astro.build/en/reference/modules/astro-actions/#actioninputschema
 */
export type ActionInputSchema<T extends ActionClient<any, any, any>> = T extends {
	[inferSymbol]: any;
}
	? T[typeof inferSymbol]
	: never;

export type ActionClient<
	TOutput,
	TAccept extends ActionAccept | undefined,
	TInputSchema extends z.ZodType | undefined,
> = TInputSchema extends z.ZodType
	? ((
			input: TAccept extends 'form' ? FormData : z.input<TInputSchema>,
		) => Promise<
			SafeResult<
				z.input<TInputSchema> extends ErrorInferenceObject
					? z.input<TInputSchema>
					: ErrorInferenceObject,
				Awaited<TOutput>
			>
		>) & {
			queryString: string;

Review comment (suggestion):
```suggestion
 * Infers the type of an action's input based on its Zod schema
```

Code after:
} from './shared.js';
import type { Locals } from './utils.js';
import {
	ACTION_API_CONTEXT_SYMBOL,
	type ActionAPIContext,
	type ErrorInferenceObject,
	formContentTypes,
	hasContentType,
	isActionAPIContext,
	type MaybePromise,
} from './utils.js';

export * from './shared.js';

export type ActionAccept = 'form' | 'json';

export type ActionHandler<TInputSchema, TOutput> = TInputSchema extends z.ZodType
	? (input: z.infer<TInputSchema>, context: ActionAPIContext) => MaybePromise<TOutput>
	: (input: any, context: ActionAPIContext) => MaybePromise<TOutput>;

export type ActionReturnType<T extends ActionHandler<any, any>> = Awaited<ReturnType<T>>;

const inferSymbol = Symbol('#infer');

/**
 * Infers the type of an action's input based on its Zod schema
 *
 * @see https://docs.astro.build/en/reference/modules/astro-actions/#actioninputschema
 */
export type ActionInputSchema<T extends ActionClient<any, any, any>> = T extends {
	[inferSymbol]: any;
}
	? T[typeof inferSymbol]
	: never;

export type ActionClient<
	TOutput,
	TAccept extends ActionAccept | undefined,
	TInputSchema extends z.ZodType | undefined,
> = TInputSchema extends z.ZodType
	? ((
			input: TAccept extends 'form' ? FormData : z.input<TInputSchema>,
		) => Promise<
			SafeResult<
				z.input<TInputSchema> extends ErrorInferenceObject
					? z.input<TInputSchema>
					: ErrorInferenceObject,
				Awaited<TOutput>
			>
		>) & {
			queryString: string;
Repository: withastro/astro
File: packages/astro/test/fixtures/content-layer/src/loaders/post-loader.ts (TypeScript)

Code before:
			if (lastSynced && (Date.now() - Number(lastSynced) < 1000 * 60)) {
					logger.info('Skipping sync');
					return;
			}

			const posts = await fetch(config.url)
				.then((res) => res.json());

			store.clear();

			for (const data of posts) {
				store.set({id: data.id, data});
			}
			meta.set('lastSynced', String(Date.now()));
		},
		getSchemaContext: async () => {
			// Simulate a delay
			await new Promise((resolve) => setTimeout(resolve, 1000));
			return {
				schema: z.object({
				title: z.string(),
				body: z.string(),
				userId: z.number(),
				id: z.number(),
			}),
			types: `export intreface Collection {
	title: string;
	body: string;
	userId: number;
	id: number;
}`
			}
		}
	};
}


Review comment (suggestion):
```suggestion
			types: `export interface Collection {
```

Small typo, which I guess would be more common with this approach.

Code after:
			if (lastSynced && (Date.now() - Number(lastSynced) < 1000 * 60)) {
					logger.info('Skipping sync');
					return;
			}

			const posts = await fetch(config.url)
				.then((res) => res.json());

			store.clear();

			for (const data of posts) {
				store.set({id: data.id, data});
			}
			meta.set('lastSynced', String(Date.now()));
		},
		createSchema: async () => {
			// Simulate a delay
			await new Promise((resolve) => setTimeout(resolve, 1000));
			return {
				schema: z.object({
				title: z.string(),
				body: z.string(),
				userId: z.number(),
				id: z.number(),
			}),
			types: /* ts */`export interface Entry {
	title: string;
	body: string;
	userId: number;
	id: number;
}`
			}
		}
	};
}