Search

1. Create proxy val for your turso DB (make it private to protect it behind your val town token)

export default createTursoProxy("<tursoDatabaseUrl>", "<tursoAuthToken>")

2. Wire any existing val to the proxy val

export function createTursoProxy(databaseUrl: string, authToken: string) {

const client = createClient({

url: `${databaseUrl}?authToken=${Deno.env.get("TURSO_AUTH_TOKEN")}`,

const app = new Hono();

🏗️ *Work-in-progress!* 🏗️

The idea is to create a reusable course generator Val designed with effective, research-backed learning techniques in mind. That includes techniques like spaced repetition (via an interval between email lessons), retrieval practice (quizzing and fill-in-the-blank), elaboration and reflection (writing exercises). The Val(s) will include:

- Email signup and verification

- Template to fill in with course content

- SQLite tables to store students and track progress

export async function emailSubscription(req: Request) {

const app = new Hono();

app.get("/", async (c) => {

return c.html(fetchSignupHtml());

import { ping } from "https://esm.town/v/alp/ping";

export const log = async (req, res) => {

await ping();

res.json({

forwardedFor: req.headers["x-forwarded-for"],

remoteAddress: req.connection.remoteAddress,

ip: req.ip,

export async function ghIssueFromNodeId(nodeId: string, token: string): Promise<{

id: string;

number: number;

repository: string;

owner: string;

const { Octokit } = await import("npm:@octokit/core");

const octokit = new Octokit({ auth: token });

const graphqlVariables = {

nodeId,

const query = `

async function fetchRandomJoke() {

const response = await fetch(

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

return response.json();

const randomJoke = await fetchRandomJoke();

const setup = randomJoke.setup;

const punchline = randomJoke.punchline;

export const emailRandomJoke = email({

import { getWebLoaderBuilder } from "https://esm.town/v/webup/getWebLoaderBuilder";

export const loaderSampleAudio = (async () => {

const builder = await getWebLoaderBuilder(

"https://storage.googleapis.com/aai-docs-samples/sports_injuries.mp3",

"audio",

{ language_code: "en_us" },

const loader = await builder();

return await loader.load();

link to val - https://www.val.town/v/fal/svd

const result = await fal.subscribe("fal-ai/fast-svd", {

input: {

export let sd_video = async (

image_url: string,

motion_bucket_id: number = 127,

cond_aug: number = 0.02,

import { traverse } from "https://esm.town/v/jdan/traverse";

export const randomCommutes = (() => {

for (let i = 0; i < 10; i++) {

console.log(traverse(dailyCommute));

import { welcomeEmail } from "https://esm.town/v/rodrigotello/welcomeEmail?v=142";

export let emailMe = console.email({

html: welcomeEmail,

subject: "Welcome to Val Town",

export let secPerMin = 60;

export let heapify = (arr) => {

// maxHeap

const swapDown = (arr, n, i) => {

// Recursively swap entries if they are less than their children.

// The first index to be checked will be the last non-leaf (floor(n/2 - 1)),

// since we only really call this from insert and delete.

let largest = i; // assume the current index is the largest.

const left = 2 * i + 1; // because math (binary tree)

const right = 2 * i + 2; // because math

// Check if left child of current node is greater, satisfying the heap

export function currentDate() {

return new Date();

export let hackerNewsAuthors = ["stevekrouse", "dustingetz"];

export const addLinkHandler = async (c) => {

try {

const payload = await c.get('jwtPayload');

const body = await c.req.parseBody();

const label = body.label;

const url = body.url;

if (!label || !url) {

return c.json({ error: 'Label and URL are required' }, 400);

export let consoleEmailEx = (() => {

console.email("message"); // any JSON object can be the message