Val Town Code SearchReturn to Val Town

1export async function pollEnabledStatus() {
2  // this shouldn't run forever just b/c someone forgot to close their browser tab with the demo in it
3  const interval = 1000; // 10000;

EnhancedVNodeREADME.md3 matches

@Teddy2100•Updated 1 day ago

1# EnhancedVNode
2
3A minimalist, plugin-ready hyperscript-style utility for rendering elements with style normalization, class processing, and custom behavioral plugins. Compatible with React, Preact, or any functionally similar createElement.
4
5## ✨ Features
6
7- 🧱 Lightweight functional interface: const h = new EnhancedVNode(createElement)
8- 🎨 Normalizes class strings into Set and filters empty entries
9- 🎛️ Parses inline style into clean JS objects
46## 🔌 Plugins
47
48Plugins are just functions that receive and mutate the props object before rendering:
49
50```js

11import {registerPrompts} from "./prompts/promptsTools.ts"
12
13export function registerTools(
14  server: McpServer,
15  config: Config,
29}
30
31export function registerPromptsTools(server: McpServer, config: Config) {
32    registerPrompts(server, config)
33}

23- Respond in a friendly and concise manner
24- Ask clarifying questions when requirements are ambiguous
25- Provide complete, functional solutions rather than skeleton implementations
26- Test your logic against edge cases before presenting the final solution
27- Ensure all code follows Val Town's specific platform requirements
36- **Never bake in secrets into the code** - always use environment variables
37- Include comments explaining complex logic (avoid commenting obvious operations)
38- Follow modern ES6+ conventions and functional programming practices where appropriate
39
40### Val Town Utility Functions
41
42Val Town provides several utility functions to help with common project tasks. These utilities handle file management, project information, and testing.
43
44### Importing Utilities
90      {
91        name: "should add numbers correctly",
92        function: () => {
93          expect(1 + 1).toBe(2);
94        },
174│   ├── database/
175│   │   ├── migrations.ts    # Schema definitions
176│   │   ├── queries.ts       # DB query functions
177│   │   └── README.md
178│   ├── index.ts             # Main entry point
190└── shared/
191    ├── README.md
192    └── utils.ts             # Shared types and functions
193```
194
196- Hono is the recommended API framework (similar to Express, Flask, or Sinatra)
197- Main entry point should be `backend/index.ts`
198- **Static asset serving:** Use the utility functions to read and serve project files:
199  ```ts
200  // Use the serveFile utility to handle content types automatically
237- Run migrations on startup or comment out for performance
238- Change table names when modifying schemas rather than altering
239- Export clear query functions with proper TypeScript typing
240- Follow the queries and migrations pattern from the example
241

10- **Never bake in secrets into the code** - always use environment variables
11- Include comments explaining complex logic (avoid commenting obvious operations)
12- Follow modern ES6+ conventions and functional programming practices if possible
13
14## Types of triggers
21
22```ts
23export default async function (req: Request) {
24  return new Response("Hello World");
25}
35
36```ts
37export default async function () {
38  // Scheduled task code
39}
49
50```ts
51export default async function (email: Email) {
52  // Process email
53}
58## Val Town Standard Libraries
59
60Val Town provides several hosted services and utility functions.
61
62### Blob Storage
112```
113
114## Val Town Utility Functions
115
116Val Town provides several utility functions to help with common project tasks.
117
118### Importing Utilities
191│   ├── database/
192│   │   ├── migrations.ts    # Schema definitions
193│   │   ├── queries.ts       # DB query functions
194│   │   └── README.md
195│   └── routes/              # Route modules
210└── shared/
211    ├── README.md
212    └── utils.ts             # Shared types and functions
213```
214
217- Hono is the recommended API framework
218- Main entry point should be `backend/index.ts`
219- **Static asset serving:** Use the utility functions to read and serve project files:
220  ```ts
221  import { readFile, serveFile } from "https://esm.town/v/std/utils@85-main/index.ts";
251- Run migrations on startup or comment out for performance
252- Change table names when modifying schemas rather than altering
253- Export clear query functions with proper TypeScript typing
254
255## Common Gotchas and Solutions

10  1. `http`: http vals export a default server request handler.
11  2. `script`: script vals can be imported into other vals, similar to an npm package.
12  3. `cron`: cron vals export a function that can automatically run at user-set intervals, similar to a cron command.
13  4. `email`: email vals export a function that runs when its associated email address receives an email.
14
15Follow these requirements for Val Town when generating code.
49</requirements>
50
51If the user asks for specific functionality, the Val Town standard library includes the following:
52
53<libraries>
63    ```
64
65    Blob storage only works on the server. If the val includes client-side code, use dynamic imports to import this module in the server function, e.g.:
66    `const { blob } = await import("https://esm.town/v/std/blob");`
67  </library>
78    If you are changing a SQLite table's schema, you should also change the table's name so it creates a fresh table, ie by adding _2 or _3 after it everywhere. Ensure that tables are created before they are used.
79
80    SQLite storage only works on the server. If the val includes client-side code, use dynamic imports to import this module in the server function, e.g.:
81    `const { sqlite } = await import("https://esm.town/v/stevekrouse/sqlite");`
82  </library>
99    ```
100
101    OpenAI only works on the server. If the val includes client-side code, use dynamic imports to import this module in the server function, e.g.:
102    `const { OpenAI } = await import "https://esm.town/v/std/openai");`
103  </library>
113    ```
114
115    Email only works on the server. If the val includes client-side code, use dynamic imports to import this module in the server function, e.g.:
116    `const { email } = await import "https://esm.town/v/std/email");`
117  </library>
131    Write the code in ```val code fences.
132    Include the val type as metadata on the code fence, e.g.: ```val type=script
133    If this is a new val, decide what val type is appropriate based on the user's prompt. Default to choosing http type vals unless the user has requested specific functionality that requires a different type.
134
135  * If the user requests diff format in their prompt, follow these steps:
157 * Use fetch to communicate with the backend server portion.
158 */
159function App() {
160  return (
161    <div>
167/**
168 * Client-only code
169 * Any code that makes use of document or window should be scoped to the `client()` function.
170 * This val should not cause errors when imported as a module in a browser.
171 */
172function client() {
173  createRoot(document.getElementById("root")).render(<App />);
174}
177/**
178 * Server-only code
179 * Any code that is meant to run on the server should be included in the server function.
180 * This can include endpoints that the client side component can send fetch requests to.
181 */
182export default async function server(request: Request): Promise<Response> {
183  /** If needed, blob storage or sqlite can be imported as a dynamic import in this function.
184   * Blob storage should never be used in the browser directly.
185   * Other server-side specific modules can be imported in a similar way.
232  ```val type=script
233  /** Use this template for creating script vals only */
234  export default function () {
235    return "Hello, world";
236  }
243  ```val type=cron
244  /** Use this template for creating cron vals only */
245  export default async function (interval: Interval) {
246    // code will run at an interval set by the user
247    console.log(`Hello, world: ${Date.now()}`);
270  // The email address for this val will be `<username>.<valname>@valtown.email` which can be derived from:
271  // const emailAddress = new URL(import.meta.url).pathname.split("/").slice(-2).join(".") + "@valtown.email";
272  export default async function (e: Email) {
273    console.log("Email received!", email.from, email.subject, email.text);
274  }

6## Understanding Val Town
7
8Val Town is a platform for writing, running, and deploying JavaScript/TypeScript code in the cloud. It functions as a social coding environment where users can create and share code that runs on Val Town's serverless infrastructure.
9
10### Val Town Projects
21## Core Guidelines
22
23- Provide complete, functional solutions
24- Test logic against edge cases
25- Follow Val Town's platform requirements
26- Write clean, maintainable TypeScript/TSX code
27- Add appropriate TypeScript types for all data structures
28- Prefer functional programming practices where appropriate
29
30## Coding Requirements

8
9// Register prompt capabilities with server
10export function registerPrompts(server: McpServer, _config: Config) {
11  // Townie prompt 
12  server.prompt(

5import {getErrorMessage} from "../lib/errorUtils.ts"
6
7export function registerSqliteTools(server: McpServer, config: Config) {
8  // Execute SQL
9  server.tool(
64  )
65
66  // Fix for sqlite-query function
67  server.tool(
68    "sqlite-query",
91  )
92
93  // Fix for sqlite-exec function
94  server.tool(
95    "sqlite-exec",

6import {z} from "npm:zod"
7
8export function registerValTools(server: McpServer, config: Config) {
9  // Get val by username and val name
10  server.tool(