Search

const INITIAL_SNAKE = [{ x: 10, y: 10 }];

function SnakeGame() {

const [snake, setSnake] = useState(INITIAL_SNAKE);

useEffect(() => {

async function fetchHighScore() {

const { blob } = await import("https://esm.town/v/std/blob");

if (score > highScore) {

async function updateHighScore() {

const { blob } = await import("https://esm.town/v/std/blob");

}, [score, highScore]);

function generateFood() {

return {

</div>

function client() {

createRoot(document.getElementById("root")).render(<SnakeGame />);

if (typeof document !== "undefined") { client(); }

export default async function server(request: Request): Promise<Response> {

return new Response(`

import { mail } from "https://esm.town/v/stevekrouse/mail";

import { runVal } from "https://esm.town/v/std/runVal";

export async function emailGPT3(email) {

let response = await runVal("patrickjm.gpt3", { prompt: email.text });

return mail({

import { searchParams } from "https://esm.town/v/stevekrouse/searchParams?v=9";

import { fetchJSON } from "https://esm.town/v/stevekrouse/fetchJSON?v=41";

export function comments({ token, since, until, offset, limit, relationship }: {

token: string;

since?: Date;

signFn?: (message: string, pkcs8: string, algorithm: SignatureOptions["algorithm"]) => Promise<string>;

export function createSignedFetch(

options: SignatureOptions & {

const fetch = options.fetch ?? globalThis.fetch;

return async function signedFetch(

input: Request | URL | string,

return fetch(signedReq);

export async function signRequest(

input: Request | URL | string,

return req;

function createMessage(req: Request) {

const { pathname, search } = new URL(req.url);

return message;

function createSignatureHeader(

signature: string,

.join(",");

export async function nodeSign(

message: string,

throw new TypeError(`error: unsupported algorithm: ${algorithm}`);

export async function webcryptoSign(

message: string,

function fetchRandomJoke() {

const SAMPLE_JOKE = {

"setup": "What do you call a group of disorganized cats?",

import { email } from "https://esm.town/v/std/email?v=9";

function fetchRandomJoke() {

const SAMPLE_JOKE = {

"setup": "What do you call a group of disorganized cats?",

import { email } from "https://esm.town/v/std/email?v=9";

async function fetchRandomJoke() {

const response = await fetch(

"https://official-joke-api.appspot.com/random_joke",

</div>

function App() {

const [state, setState] = useState({

100% { transform: rotate(360deg); }

function client() {

createRoot(document.getElementById("root")).render(<App />);

client();

export default async function server(request: Request): Promise<Response> {

return new Response(

* and activity (befriends aliens, goes to the doctor, rides a rollercoaster, bakes a cake for friends)

It uses OpenAI to write a children's bedtime story

* title

for a "fantastical story about a green whale who rides the bus" or the "spooky story about the tomato fox who explores a cave".

Then using the summary, OpenAI geenrates another prompt to describe the instructions to geneate a childrens story book image.

That's sent to Fal to generate an image.

import { ValTownLink } from "https://esm.town/v/dthyresson/viewOnValTownComponent"

import { chat } from "https://esm.town/v/stevekrouse/openai"

import * as fal from "npm:@fal-ai/serverless-client"

function parseStory(text) {

// Split the text into lines and remove empty lines

export function replyJSON(data: any, status: number) {

return new Response(JSON.stringify(data), {

headers: { "Content-Type": "application/json" },

export function replyText(data: string, status: number) {

return new Response(data, {

headers: { "Content-Type": "text/plain" },

export function opNotFoundError(opName: string) {

return {

info: { opName },

function formatGetBody(url: string, info: ExtInfo) {

const { ns = "?", title = "?" } = info ?? {};

type HandleRequestFn = (info: any) => Promise<any>;

export function makeExtServer(getInfo: GetInfoFn, handleRequest: HandleRequestFn) {

return async (req: Request) => {

export function insecureFetch(input: string | URL | Request, init?: RequestInit) {

const origReq = new Request(input, init);

const proxyURL = new URL("https://unsecure-fetch.val-town.workers.dev");

import { minify } from "npm:terser";

const app = new Hono();

async function bookmarkletUrl(author: string, name: string) {

const resp = await fetch(`https://esm.town/v/${author}/${name}`);

const { code } = await minify(await resp.text());

"That's it I'm stealing your pc",

function App() {

const [noClicks, setNoClicks] = useState(0);

</div>

function client() {

createRoot(document.getElementById("root")).render(<App />);

if (typeof document !== "undefined") { client(); }

export default async function server(request: Request): Promise<Response> {

return new Response(

import { html } from "https://esm.town/v/stevekrouse/html";

export async function echoParams(

req: Request

const url = new URL(req.url)

<div id="plotContainer"></div>

<script>

async function main() {

let pyodide = await loadPyodide();

await pyodide.loadPackage(['numpy', 'pandas', 'matplotlib']);

// `shiki/wasm` contains the wasm binary inlined as base64 string.

engine: createOnigurumaEngine(shikiWasm),

export default async function(req: Request): Promise<Response> {

if (req.method !== "POST") return new Response(null, { status: 405 });

const { searchParams } = new URL(req.url);