Search

[Browserbase](https://www.browserbase.com/) is a developer platform to run, manage, and monitor headless browsers at scale. We’ll use Browserbase to navigate to, and scrape our different news sources. We’ll also use [Browserbase’s Proxies](https://docs.browserbase.com/features/stealth-mode#proxies-and-residential-ips) to ensure we simulate authentic user interactions across multiple [browser sessions](https://docs.browserbase.com/features/sessions).

Get started with Browserbase for free [here](https://www.browserbase.com/sign-up).

writer.write(textEncoder.encode(text)); // Remove 'await' here

writer.close(); // This can be awaited if needed

// Send the readable stream back to the client

return new Response(readable, {

headers: {

[Lit](https://lit.dev/docs/ssr/server-usage/) is kind of like Google's answer to React: it's a little more reliant on browser APIs like custom elements and the shadow DOM, a little less 'magic', like using JSX.

This is an example of using Lit and rendering it straight to a string, which is something that's recently popular. It works pretty well, right off the bat: Lit provides nice ESM modules and a pretty smooth workflow!

const planeHeight = planeWidth / aspectRatio;

const geometry = new THREE.PlaneGeometry(planeWidth, planeHeight);

const material = new THREE.MeshBasicMaterial({ map: texture, side: THREE.DoubleSide, transparent: true });

const plane = new THREE.Mesh(geometry, material);

scene.add(plane);

auth: string;

//const { LemmyHttp } = await import("npm:lemmy-js-client");

const { LemmyHttp } = await import("npm:lemmy-js-client@0.18.1");

let client = new LemmyHttp(`https://${instance}`, {

fetchFunction: fetch,

try {

const ret = await client.createPost({

community_id: communityId,

next.end += prefix.length + suffix.length;

return;

// Markup inside has to take account of prefix + suffix

next.start += prefix.length;

next.end += prefix.length;

import { Hono } from "jsr:@hono/hono";

import { createClient } from "npm:@libsql/client";

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

const client = createClient({

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

return new Response("No statements", { status: 400 });

const res = await client.batch(statements, mode);

return new Response(JSON.stringify(res));

return new Response("No statement", { status: 400 });

const res = await client.execute(statement);

return new Response(JSON.stringify(res));

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

const result = await fal.subscribe("fal-ai/creative-upscaler", {

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

export let creativeUpscaler = async (

prompt: string,

import { extractValInfo } from "https://esm.town/v/pomdtr/extractValInfo";

import { Hono } from "npm:hono";

const clientID = Deno.env.get("GITHUB_CLIENT_ID");

const clientSecret = Deno.env.get("GITHUB_CLIENT_SECRET");

const app = new Hono();

export default app.fetch;

li {

margin-bottom: 10px;

aside {

margin-top: 8px;

margin-bottom: 8px;

.fish {

position: absolute;

right: -50px; /* Start outside the viewport */

animation: swim linear infinite;

@keyframes swim {

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

import { Hono } from "npm:hono";

import { JSX } from "npm:react";

export async function emailSubscription(req: Request) {

const app = new Hono();

text: `Verification complete for ${email}'s subscription to: Make It Stick (in 10 days, via email)`,

return Response.json({ confirmed: true, message: "Verified email address." });

* TODO: POST requests are blocked for security reasons on mobile email clients.

* I could use a GET request with a req body, but that's a hack/anti-pattern.

* I don't want to move the form to a webpage because it should be in the lesson flow.

export async function refreshTwitterToken(

{ refresh_token, client_id, client_secret }: {

refresh_token: string;

client_id: string;

client_secret: string;

const url = "https://api.twitter.com/2/oauth2/token";

refresh_token,

client_id,

return fetchJSON(url, {

"Content-Type": "application/x-www-form-urlencoded",

...basicAuthorization(client_id, client_secret),

body: body.toString(),

constructor() {

super();

// Declare reactive properties

this.name = "World";

// Render the UI as a function of component state

const { PostHog } = await import("npm:posthog-node");

const client = new PostHog(key, {

host: host,

client.capture({

distinctId: distinct_id,

timestamp: timestamp,

client.on("error", (err) => {

console.log(err);

// flush events because this is short-lived process

await client.shutdown();

return "Event captured";

[PGlite](http://pglite.dev) is a WASM Postgres build packaged into a TypeScript client library that enables you to run Postgres in the browser, Node.js, Bun and Deno, with no need to install any other dependencies. It is only 3mb gzipped and has support for many Postgres extensions, including pgvector.

Read more about PGlite here: http://pglite.dev