Add TypeScript WASM guest runtime and examples.

client/testfixture/guests/typescript/.gitignore

@@ -0,0 +1,2 @@
+dist/
+node_modules/

client/testfixture/guests/typescript/eslint.config.mjs

@@ -0,0 +1,30 @@
+import pluginJs from "@eslint/js";
+import tseslint from "typescript-eslint";
+
+export default [
+  pluginJs.configs.recommended,
+  ...tseslint.configs.recommended,
+  {
+    ignores: ["dist/", "node_modules/"],
+  },
+  {
+    files: ["src/**/*.{js,mjs,cjs,mts,ts,tsx,jsx}"],
+    rules: {
+      // https://typescript-eslint.io/rules/no-explicit-any/
+      "@typescript-eslint/no-explicit-any": "warn",
+      "@typescript-eslint/no-wrapper-object-types": "warn",
+      "@typescript-eslint/no-namespace": "off",
+      "no-var": "off",
+      // http://eslint.org/docs/rules/no-unused-vars
+      "@typescript-eslint/no-unused-vars": [
+        "error",
+        {
+          vars: "all",
+          args: "after-used",
+          argsIgnorePattern: "^_",
+          varsIgnorePattern: "^_",
+        },
+      ],
+    },
+  },
+];

client/testfixture/guests/typescript/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "wasm-ts-guest-testfixture",
+  "private": true,
+  "version": "0.0.0",
+  "scripts": {
+    "generate:types": "jco types ../../../../guests/typescript/wit/ -o generated/types",
+    "build:tsc": "vite build",
+    "build:wasm": "jco componentize dist/index.mjs -w ../../../../guests/typescript/wit -o dist/wasm_ts_guest_testfixture.wasm",
+    "build:wasm:aot": "jco componentize  dist/index.mjs -w ../../../../guests/typescript/wit --aot -o dist/wasm_ts_guest_testfixture.wasm",
+    "build": "npm run build:tsc && npm run build:wasm",
+    "check": "tsc --noEmit --skipLibCheck && eslint",
+    "deploy": "npm run build && rm -rf ../../wasm/* && cp dist/wasm_ts_guest_testfixture.wasm ../../wasm/",
+    "format": "prettier -w src"
+  },
+  "dependencies": {
+    "trailbase-wasm": "workspace:*"
+  },
+  "devDependencies": {
+    "@bytecodealliance/componentize-js": "^0.18.4",
+    "@bytecodealliance/jco": "^1.13.3",
+    "@eslint/js": "^9.33.0",
+    "@types/node": "^24.3.0",
+    "eslint": "^9.33.0",
+    "prettier": "^3.6.2",
+    "typescript": "^5.9.2",
+    "typescript-eslint": "^8.39.1",
+    "vite": "^7.1.2"
+  }
+}

client/testfixture/guests/typescript/src/component.js

@@ -0,0 +1,3 @@
+import e from "./index";
+
+export const { initEndpoint, incomingHandler } = e;

client/testfixture/guests/typescript/src/index.ts

@@ -0,0 +1,106 @@
+import { defineConfig } from "trailbase-wasm";
+import {
+  HttpError,
+  HttpHandler,
+  OutgoingResponse,
+  Request,
+  StatusCode,
+  buildJsonResponse,
+} from "trailbase-wasm/http";
+import { execute, query } from "trailbase-wasm/db";
+
+export default defineConfig({
+  httpHandlers: [
+    HttpHandler.get("/fibonacci", (req: Request): string => {
+      const n = req.getQueryParam("n");
+      return `${fibonacci(n ? parseInt(n) : 40)}\n`;
+    }),
+    HttpHandler.get("/json", jsonHandler),
+    HttpHandler.post("/json", jsonHandler),
+    HttpHandler.get("/fetch", async (req: Request): Promise<string> => {
+      const url = req.getQueryParam("url");
+      if (url) {
+        return await (await fetch(url)).text();
+      }
+      throw new HttpError(StatusCode.BAD_REQUEST, `Missing ?url param`);
+    }),
+    HttpHandler.get("/error", () => {
+      throw new HttpError(StatusCode.IM_A_TEAPOT, "I'm a teapot");
+    }),
+    HttpHandler.get("/await", async (req) => {
+      const ms = req.getQueryParam("ms");
+      await delay(ms ? parseInt(ms) : 10);
+
+      // Bodies over 2kB/4kB are streamed.
+      return "A".repeat(5000);
+    }),
+    HttpHandler.get("/addDeletePost", async () => {
+      const userId = (
+        await query("SELECT id FROM _user WHERE email = 'admin@localhost'", [])
+      )[0][0];
+
+      console.info("user id:", userId);
+
+      const now = Date.now().toString();
+      const numInsertions = await execute(
+        `INSERT INTO post (author, title, body) VALUES (?1, 'title' , ?2)`,
+        [userId, now],
+      );
+
+      const numDeletions = await execute(`DELETE FROM post WHERE body = ?1`, [
+        now,
+      ]);
+
+      console.assert(numInsertions === numDeletions);
+
+      return "Ok";
+    }),
+    HttpHandler.get("/set_interval", async (): Promise<string> => {
+      var cnt = 0;
+
+      console.log(`Registering callback`);
+      const handle = setInterval(() => {
+        console.log(`Interval: ${cnt}`);
+        cnt += 1;
+
+        if (cnt > 10) {
+          clearInterval(handle);
+        }
+      }, 300);
+
+      return `setInterval from Javascript`;
+    }),
+    HttpHandler.get("/random", async (): Promise<string> => {
+      return `${Math.random().toString()}\n`;
+    }),
+  ],
+});
+
+function jsonHandler(req: Request): OutgoingResponse {
+  const json = req.json();
+  return buildJsonResponse(
+    json ?? {
+      int: 5,
+      real: 4.2,
+      msg: "foo",
+      obj: {
+        nested: true,
+      },
+    },
+  );
+}
+
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function fibonacci(num: number): number {
+  switch (num) {
+    case 0:
+      return 0;
+    case 1:
+      return 1;
+    default:
+      return fibonacci(num - 1) + fibonacci(num - 2);
+  }
+}

client/testfixture/guests/typescript/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "es2022",                          /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    "module": "es2022",                          /* Specify what module code is generated. */
+    "moduleResolution": "bundler",
+    "paths": {},
+    "outDir": "./dist/",                         /* Specify an output folder for all emitted files. */
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,    /* Ensure that casing is correct in imports. */
+    "strict": true,                              /* Enable all strict type-checking options. */
+    "skipLibCheck": true                         /* Skip type checking all .d.ts files. */
+  }
+}

client/testfixture/guests/typescript/vite.config.ts

@@ -0,0 +1,19 @@
+import { defineConfig } from "vite";
+
+export default defineConfig({
+  build: {
+    outDir: "./dist",
+    minify: false,
+    lib: {
+      entry: "./src/component.js",
+      name: "runtime",
+      fileName: "index",
+      formats: ["es"],
+    },
+    rollupOptions: {
+      external: (source) => {
+        return source.startsWith("wasi:") || source.startsWith("trailbase:");
+      },
+    },
+  },
+})

examples/wasm-guest-js/.gitignore

@@ -0,0 +1,3 @@
+dist/
+node_modules/
+traildepot/

examples/wasm-guest-js/Makefile

@@ -0,0 +1,22 @@
+TRAILBIN ?= RUST_BACKTRACE=1 cargo run --
+TRAILDEPOT := traildepot
+
+APPDIR := .
+DISTDIR := ${APPDIR}/dist
+ADDRESS := 127.0.0.1:4000
+
+run: guest
+	${TRAILBIN} --data-dir=${TRAILDEPOT} run --address=${ADDRESS}
+
+guest: ${TRAILDEPOT}/wasm/component.wasm
+
+${TRAILDEPOT}/wasm/component.wasm: ${DISTDIR}/component.wasm
+	mkdir -p ${TRAILDEPOT}/wasm && cp $< $@
+
+${DISTDIR}/component.wasm: src/*.js
+	pnpm i && pnpm build
+
+clean:
+	rm -rf dist traildepot
+
+.PHONY: guest run clean

examples/wasm-guest-js/eslint.config.mjs

@@ -0,0 +1,20 @@
+import pluginJs from "@eslint/js";
+import globals from "globals";
+
+export default [
+  pluginJs.configs.recommended,
+  {
+    ignores: ["dist/", "node_modules/"],
+  },
+  {
+    files: ["src/**/*.{js,mjs,cjs,mts,jsx}"],
+    rules: {
+      "no-var": "off",
+    },
+    languageOptions: {
+      globals: {
+        ...globals.browser,
+      }
+    }
+  },
+];

examples/wasm-guest-js/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "example-wasm-guest-js",
+  "private": true,
+  "version": "0.0.0",
+  "scripts": {
+    "build:wasm": "jco componentize dist/index.mjs -w ../../guests/typescript/wit -o dist/component.wasm",
+    "build:wasm:aot": "jco componentize dist/index.mjs -w ../../guests/typescript/wit --aot -o dist/component.wasm",
+    "build": "vite build && npm run build:wasm",
+    "check": "eslint",
+    "format": "prettier -w src"
+  },
+  "dependencies": {
+    "trailbase-wasm": "workspace:*"
+  },
+  "devDependencies": {
+    "@bytecodealliance/componentize-js": "^0.18.4",
+    "@bytecodealliance/jco": "^1.13.3",
+    "@eslint/js": "^9.33.0",
+    "eslint": "^9.33.0",
+    "globals": "^16.3.0",
+    "prettier": "^3.6.2",
+    "vite": "^7.1.2"
+  }
+}

examples/wasm-guest-js/src/component.js

@@ -0,0 +1,3 @@
+import e from "./index";
+
+export const { initEndpoint, incomingHandler } = e;

examples/wasm-guest-js/src/index.js

@@ -0,0 +1,71 @@
+import { defineConfig, addPeriodicCallback } from "trailbase-wasm";
+import { HttpHandler, buildJsonResponse } from "trailbase-wasm/http";
+import { JobHandler } from "trailbase-wasm/job";
+import { query } from "trailbase-wasm/db";
+
+export default defineConfig({
+  httpHandlers: [
+    HttpHandler.get("/fibonacci", (req) => {
+      const n = req.getQueryParam("n");
+      return fibonacci(n ? parseInt(n) : 40).toString();
+    }),
+    HttpHandler.get("/json", jsonHandler),
+    HttpHandler.post("/json", jsonHandler),
+    HttpHandler.get("/a", (req) => {
+      const n = req.getQueryParam("n");
+      return "a".repeat(n ? parseInt(n) : 5000);
+    }),
+    HttpHandler.get("/interval", () => {
+      let i = 0;
+      addPeriodicCallback(250, (cancel) => {
+        console.log(`callback #${i}`);
+        i += 1;
+        if (i >= 10) {
+          cancel();
+        }
+      });
+    }),
+    HttpHandler.get("/sleep", async (req) => {
+      const param = req.getQueryParam("ms");
+      const ms = param ? parseInt(param) : 500;
+      await sleep(ms);
+      return `slept: ${ms}ms`;
+    }),
+    HttpHandler.get("/count/{table}/", async (req) => {
+      const table = req.getPathParam("table");
+      if (table) {
+        const rows = await query(`SELECT COUNT(*) FROM ${table}`, []);
+        return `Got ${rows[0][0]} rows\n`;
+      }
+    }),
+  ],
+  jobHandlers: [JobHandler.minutely("myjob", () => console.log("Hello Job!"))],
+});
+
+function jsonHandler(req) {
+  return buildJsonResponse(
+    req.json() ?? {
+      int: 5,
+      real: 4.2,
+      msg: "foo",
+      obj: {
+        nested: true,
+      },
+    },
+  );
+}
+
+function fibonacci(num) {
+  switch (num) {
+    case 0:
+      return 0;
+    case 1:
+      return 1;
+    default:
+      return fibonacci(num - 1) + fibonacci(num - 2);
+  }
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

examples/wasm-guest-js/vite.config.ts

@@ -0,0 +1,16 @@
+import { defineConfig } from "vite";
+
+export default defineConfig({
+  build: {
+    outDir: "./dist",
+    minify: false,
+    lib: {
+      entry: "./src/component.js",
+      fileName: "index",
+      formats: ["es"],
+    },
+    rollupOptions: {
+      external: (source) => source.startsWith("wasi:") || source.startsWith("trailbase:"),
+    },
+  },
+})

examples/wasm-guest-ts/.gitignore

@@ -0,0 +1,3 @@
+dist/
+node_modules/
+traildepot/

examples/wasm-guest-ts/Makefile

@@ -0,0 +1,22 @@
+TRAILBIN ?= RUST_BACKTRACE=1 cargo run --
+TRAILDEPOT := traildepot
+
+APPDIR := .
+DISTDIR := ${APPDIR}/dist
+ADDRESS := 127.0.0.1:4000
+
+run: guest
+	${TRAILBIN} --data-dir=${TRAILDEPOT} run --address=${ADDRESS}
+
+guest: ${TRAILDEPOT}/wasm/component.wasm
+
+${TRAILDEPOT}/wasm/component.wasm: ${DISTDIR}/component.wasm
+	mkdir -p ${TRAILDEPOT}/wasm && cp $< $@
+
+${DISTDIR}/component.wasm: src/*.ts
+	pnpm i && pnpm build
+
+clean:
+	rm -rf dist traildepot
+
+.PHONY: guest run clean

examples/wasm-guest-ts/eslint.config.mjs

@@ -0,0 +1,30 @@
+import pluginJs from "@eslint/js";
+import tseslint from "typescript-eslint";
+
+export default [
+  pluginJs.configs.recommended,
+  ...tseslint.configs.recommended,
+  {
+    ignores: ["dist/", "node_modules/"],
+  },
+  {
+    files: ["src/**/*.{js,mjs,cjs,mts,ts,tsx,jsx}"],
+    rules: {
+      // https://typescript-eslint.io/rules/no-explicit-any/
+      "@typescript-eslint/no-explicit-any": "warn",
+      "@typescript-eslint/no-wrapper-object-types": "warn",
+      "@typescript-eslint/no-namespace": "off",
+      "no-var": "off",
+      // http://eslint.org/docs/rules/no-unused-vars
+      "@typescript-eslint/no-unused-vars": [
+        "error",
+        {
+          vars: "all",
+          args: "after-used",
+          argsIgnorePattern: "^_",
+          varsIgnorePattern: "^_",
+        },
+      ],
+    },
+  },
+];

examples/wasm-guest-ts/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "example-wasm-guest-ts",
+  "private": true,
+  "version": "0.0.0",
+  "main": "dist/index.js",
+  "scripts": {
+    "generate:types": "jco types ../../guests/typescript/wit/ -o generated/types",
+    "build:tsc": "vite build",
+    "build:wasm": "jco componentize dist/index.mjs -w ../../guests/typescript/wit -o dist/component.wasm",
+    "build:wasm:aot": "jco componentize  dist/index.mjs -w ../../guests/typescript/wit --aot -o dist/component.wasm",
+    "build": "npm run build:tsc && npm run build:wasm",
+    "check": "tsc --noEmit --skipLibCheck && eslint",
+    "format": "prettier -w src"
+  },
+  "dependencies": {
+    "trailbase-wasm": "workspace:*"
+  },
+  "devDependencies": {
+    "@bytecodealliance/componentize-js": "^0.18.4",
+    "@bytecodealliance/jco": "^1.13.3",
+    "@eslint/js": "^9.33.0",
+    "@types/node": "^24.3.0",
+    "eslint": "^9.33.0",
+    "prettier": "^3.6.2",
+    "typescript": "^5.9.2",
+    "typescript-eslint": "^8.39.1",
+    "vite": "^7.1.2",
+    "vitest": "^3.2.4"
+  }
+}

examples/wasm-guest-ts/src/component.ts

@@ -0,0 +1,3 @@
+import e from "./index";
+
+export const { initEndpoint, incomingHandler } = e;

examples/wasm-guest-ts/src/index.ts

@@ -0,0 +1,71 @@
+import { defineConfig, addPeriodicCallback } from "trailbase-wasm";
+import { HttpHandler, Request, buildJsonResponse } from "trailbase-wasm/http";
+import { JobHandler } from "trailbase-wasm/job";
+import { query } from "trailbase-wasm/db";
+
+export default defineConfig({
+  httpHandlers: [
+    HttpHandler.get("/fibonacci", (req: Request) => {
+      const n = req.getQueryParam("n");
+      return fibonacci(n ? parseInt(n) : 40).toString();
+    }),
+    HttpHandler.get("/json", jsonHandler),
+    HttpHandler.post("/json", jsonHandler),
+    HttpHandler.get("/a", (req: Request) => {
+      const n = req.getQueryParam("n");
+      return "a".repeat(n ? parseInt(n) : 5000);
+    }),
+    HttpHandler.get("/interval", () => {
+      let i = 0;
+      addPeriodicCallback(250, (cancel) => {
+        console.log(`callback #${i}`);
+        i += 1;
+        if (i >= 10) {
+          cancel();
+        }
+      });
+    }),
+    HttpHandler.get("/sleep", async (req: Request) => {
+      const param = req.getQueryParam("ms");
+      const ms: number = param ? parseInt(param) : 500;
+      await sleep(ms);
+      return `slept: ${ms}ms`;
+    }),
+    HttpHandler.get("/count/{table}/", async (req: Request) => {
+      const table = req.getPathParam("table");
+      if (table) {
+        const rows = await query(`SELECT COUNT(*) FROM ${table}`, []);
+        return `Got ${rows[0][0]} rows\n`;
+      }
+    }),
+  ],
+  jobHandlers: [JobHandler.minutely("myjob", () => console.log("Hello Job!"))],
+});
+
+function jsonHandler(req: Request) {
+  return buildJsonResponse(
+    req.json() ?? {
+      int: 5,
+      real: 4.2,
+      msg: "foo",
+      obj: {
+        nested: true,
+      },
+    },
+  );
+}
+
+function fibonacci(num: number): number {
+  switch (num) {
+    case 0:
+      return 0;
+    case 1:
+      return 1;
+    default:
+      return fibonacci(num - 1) + fibonacci(num - 2);
+  }
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

examples/wasm-guest-ts/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "es2022",                          /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    "module": "es2022",                          /* Specify what module code is generated. */
+    "moduleResolution": "bundler",
+    "paths": {},
+    "outDir": "./dist/",                         /* Specify an output folder for all emitted files. */
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,    /* Ensure that casing is correct in imports. */
+    "strict": true,                              /* Enable all strict type-checking options. */
+    "skipLibCheck": true                         /* Skip type checking all .d.ts files. */
+  }
+}

examples/wasm-guest-ts/vite.config.ts

@@ -0,0 +1,17 @@
+import { defineConfig } from "vite";
+
+export default defineConfig({
+  build: {
+    outDir: "./dist",
+    minify: false,
+    lib: {
+      entry: "./src/component.ts",
+      name: "runtime",
+      fileName: "index",
+      formats: ["es"],
+    },
+    rollupOptions: {
+      external: (source) => source.startsWith("wasi:") || source.startsWith("trailbase:"),
+    },
+  },
+})

guests/rust

@@ -0,0 +1 @@
+../crates/wasm-runtime-guest

guests/typescript/.gitignore

@@ -0,0 +1,2 @@
+dist/
+node_modules/

guests/typescript/eslint.config.mjs

@@ -0,0 +1,30 @@
+import pluginJs from "@eslint/js";
+import tseslint from "typescript-eslint";
+
+export default [
+  pluginJs.configs.recommended,
+  ...tseslint.configs.recommended,
+  {
+    ignores: ["dist/", "node_modules/"],
+  },
+  {
+    files: ["src/**/*.{js,mjs,cjs,mts,ts,tsx,jsx}"],
+    rules: {
+      // https://typescript-eslint.io/rules/no-explicit-any/
+      "@typescript-eslint/no-explicit-any": "warn",
+      "@typescript-eslint/no-wrapper-object-types": "warn",
+      "@typescript-eslint/no-namespace": "off",
+      "no-var": "off",
+      // http://eslint.org/docs/rules/no-unused-vars
+      "@typescript-eslint/no-unused-vars": [
+        "error",
+        {
+          vars: "all",
+          args: "after-used",
+          argsIgnorePattern: "^_",
+          varsIgnorePattern: "^_",
+        },
+      ],
+    },
+  },
+];

guests/typescript/generated/common/HttpContext.ts

@@ -0,0 +1,5 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+import type { HttpContextKind } from "./HttpContextKind";
+import type { HttpContextUser } from "./HttpContextUser";
+
+export type HttpContext = { kind: HttpContextKind, registered_path: string, path_params: Array<[string, string]>, user: HttpContextUser | null, };

guests/typescript/generated/common/HttpContextKind.ts

@@ -0,0 +1,3 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type HttpContextKind = "Http" | "Job";

guests/typescript/generated/common/HttpContextUser.ts

@@ -0,0 +1,15 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type HttpContextUser = {
+/**
+ * Url-safe Base64 encoded id of the current user.
+ */
+id: string,
+/**
+ * E-mail of the current user.
+ */
+email: string,
+/**
+ * The "expected" CSRF token as included in the auth token claims [User] was constructed from.
+ */
+csrf_token: string, };

guests/typescript/generated/common/SqliteRequest.ts

@@ -0,0 +1,4 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+import type { JsonValue } from "./serde_json/JsonValue";
+
+export type SqliteRequest = { query: string, params: Array<JsonValue>, };

guests/typescript/generated/common/SqliteResponse.ts

@@ -0,0 +1,4 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+import type { JsonValue } from "./serde_json/JsonValue";
+
+export type SqliteResponse = { "Query": { rows: Array<Array<JsonValue>>, } } | { "Execute": { rows_affected: number, } } | { "Error": string } | "TxBegin" | "TxCommit" | "TxRollback";

guests/typescript/generated/common/serde_json/JsonValue.ts

@@ -0,0 +1,3 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type JsonValue = number | string | boolean | Array<JsonValue> | { [key in string]?: JsonValue } | null;

guests/typescript/generated/types/interfaces/trailbase-runtime-host-endpoint.d.ts

@@ -0,0 +1,40 @@
+/** @module Interface trailbase:runtime/host-endpoint **/
+export function threadId(): bigint;
+/**
+ * NOTE: Ideally, we'd use these but they currently block guests.
+ */
+export function execute(query: string, params: Array<Value>): bigint;
+export function query(query: string, params: Array<Value>): Array<Array<Value>>;
+/**
+ * However, transactions have to be sync.
+ */
+export function txBegin(): void;
+export function txCommit(): void;
+export function txRollback(): void;
+export function txExecute(query: string, params: Array<Value>): bigint;
+export function txQuery(query: string, params: Array<Value>): Array<Array<Value>>;
+export type TxError = TxErrorOther;
+export interface TxErrorOther {
+  tag: 'other',
+  val: string,
+}
+export type Value = ValueNull | ValueText | ValueBlob | ValueInteger | ValueReal;
+export interface ValueNull {
+  tag: 'null',
+}
+export interface ValueText {
+  tag: 'text',
+  val: string,
+}
+export interface ValueBlob {
+  tag: 'blob',
+  val: Uint8Array,
+}
+export interface ValueInteger {
+  tag: 'integer',
+  val: bigint,
+}
+export interface ValueReal {
+  tag: 'real',
+  val: number,
+}

guests/typescript/generated/types/interfaces/trailbase-runtime-init-endpoint.d.ts

@@ -0,0 +1,34 @@
+/** @module Interface trailbase:runtime/init-endpoint **/
+export function init(): InitResult;
+/**
+ * # Variants
+ *
+ * ## `"get"`
+ *
+ * ## `"post"`
+ *
+ * ## `"head"`
+ *
+ * ## `"options"`
+ *
+ * ## `"patch"`
+ *
+ * ## `"delete"`
+ *
+ * ## `"put"`
+ *
+ * ## `"trace"`
+ *
+ * ## `"connect"`
+ */
+export type MethodType = 'get' | 'post' | 'head' | 'options' | 'patch' | 'delete' | 'put' | 'trace' | 'connect';
+export interface InitResult {
+  /**
+   * Registered http handlers (method, path)[].
+   */
+  httpHandlers: Array<[MethodType, string]>,
+  /**
+   * Registered jobs (name, spec)[].
+   */
+  jobHandlers: Array<[string, string]>,
+}

guests/typescript/generated/types/interfaces/wasi-clocks-monotonic-clock.d.ts

@@ -0,0 +1,34 @@
+/** @module Interface wasi:clocks/monotonic-clock@0.2.3 **/
+/**
+ * Read the current value of the clock.
+ *
+ * The clock is monotonic, therefore calling this function repeatedly will
+ * produce a sequence of non-decreasing values.
+ */
+export function now(): Instant;
+/**
+ * Query the resolution of the clock. Returns the duration of time
+ * corresponding to a clock tick.
+ */
+export function resolution(): Duration;
+/**
+ * Create a `pollable` which will resolve once the specified instant
+ * has occurred.
+ */
+export function subscribeInstant(when: Instant): Pollable;
+/**
+ * Create a `pollable` that will resolve after the specified duration has
+ * elapsed from the time this function is invoked.
+ */
+export function subscribeDuration(when: Duration): Pollable;
+export type Pollable = import('./wasi-io-poll.js').Pollable;
+/**
+ * An instant in time, in nanoseconds. An instant is relative to an
+ * unspecified initial value, and can only be compared to instances from
+ * the same monotonic-clock.
+ */
+export type Instant = bigint;
+/**
+ * A duration of time, in nanoseconds.
+ */
+export type Duration = bigint;

guests/typescript/generated/types/interfaces/wasi-clocks-wall-clock.d.ts

@@ -0,0 +1,30 @@
+/** @module Interface wasi:clocks/wall-clock@0.2.3 **/
+/**
+ * Read the current value of the clock.
+ *
+ * This clock is not monotonic, therefore calling this function repeatedly
+ * will not necessarily produce a sequence of non-decreasing values.
+ *
+ * The returned timestamps represent the number of seconds since
+ * 1970-01-01T00:00:00Z, also known as [POSIX's Seconds Since the Epoch],
+ * also known as [Unix Time].
+ *
+ * The nanoseconds field of the output is always less than 1000000000.
+ *
+ * [POSIX's Seconds Since the Epoch]: https://pubs.opengroup.org/onlinepubs/9699919799/xrat/V4_xbd_chap04.html#tag_21_04_16
+ * [Unix Time]: https://en.wikipedia.org/wiki/Unix_time
+ */
+export function now(): Datetime;
+/**
+ * Query the resolution of the clock.
+ *
+ * The nanoseconds field of the output is always less than 1000000000.
+ */
+export function resolution(): Datetime;
+/**
+ * A time and date in seconds plus nanoseconds.
+ */
+export interface Datetime {
+  seconds: bigint,
+  nanoseconds: number,
+}

guests/typescript/generated/types/interfaces/wasi-filesystem-preopens.d.ts

@@ -0,0 +1,6 @@
+/** @module Interface wasi:filesystem/preopens@0.2.3 **/
+/**
+ * Return the set of preopened directories, and their paths.
+ */
+export function getDirectories(): Array<[Descriptor, string]>;
+export type Descriptor = import('./wasi-filesystem-types.js').Descriptor;

guests/typescript/generated/types/interfaces/wasi-filesystem-types.d.ts

@@ -0,0 +1,671 @@
+/** @module Interface wasi:filesystem/types@0.2.3 **/
+/**
+ * Attempts to extract a filesystem-related `error-code` from the stream
+ * `error` provided.
+ *
+ * Stream operations which return `stream-error::last-operation-failed`
+ * have a payload with more information about the operation that failed.
+ * This payload can be passed through to this function to see if there's
+ * filesystem-related information about the error to return.
+ *
+ * Note that this function is fallible because not all stream-related
+ * errors are filesystem-related errors.
+ */
+export function filesystemErrorCode(err: Error): ErrorCode | undefined;
+export type InputStream = import('./wasi-io-streams.js').InputStream;
+export type OutputStream = import('./wasi-io-streams.js').OutputStream;
+export type Error = import('./wasi-io-streams.js').Error;
+export type Datetime = import('./wasi-clocks-wall-clock.js').Datetime;
+/**
+ * File size or length of a region within a file.
+ */
+export type Filesize = bigint;
+/**
+ * The type of a filesystem object referenced by a descriptor.
+ *
+ * Note: This was called `filetype` in earlier versions of WASI.
+ * # Variants
+ *
+ * ## `"unknown"`
+ *
+ * The type of the descriptor or file is unknown or is different from
+ * any of the other types specified.
+ * ## `"block-device"`
+ *
+ * The descriptor refers to a block device inode.
+ * ## `"character-device"`
+ *
+ * The descriptor refers to a character device inode.
+ * ## `"directory"`
+ *
+ * The descriptor refers to a directory inode.
+ * ## `"fifo"`
+ *
+ * The descriptor refers to a named pipe.
+ * ## `"symbolic-link"`
+ *
+ * The file refers to a symbolic link inode.
+ * ## `"regular-file"`
+ *
+ * The descriptor refers to a regular file inode.
+ * ## `"socket"`
+ *
+ * The descriptor refers to a socket.
+ */
+export type DescriptorType = 'unknown' | 'block-device' | 'character-device' | 'directory' | 'fifo' | 'symbolic-link' | 'regular-file' | 'socket';
+/**
+ * Descriptor flags.
+ *
+ * Note: This was called `fdflags` in earlier versions of WASI.
+ */
+export interface DescriptorFlags {
+  /**
+   * Read mode: Data can be read.
+   */
+  read?: boolean,
+  /**
+   * Write mode: Data can be written to.
+   */
+  write?: boolean,
+  /**
+   * Request that writes be performed according to synchronized I/O file
+   * integrity completion. The data stored in the file and the file's
+   * metadata are synchronized. This is similar to `O_SYNC` in POSIX.
+   *
+   * The precise semantics of this operation have not yet been defined for
+   * WASI. At this time, it should be interpreted as a request, and not a
+   * requirement.
+   */
+  fileIntegritySync?: boolean,
+  /**
+   * Request that writes be performed according to synchronized I/O data
+   * integrity completion. Only the data stored in the file is
+   * synchronized. This is similar to `O_DSYNC` in POSIX.
+   *
+   * The precise semantics of this operation have not yet been defined for
+   * WASI. At this time, it should be interpreted as a request, and not a
+   * requirement.
+   */
+  dataIntegritySync?: boolean,
+  /**
+   * Requests that reads be performed at the same level of integrity
+   * requested for writes. This is similar to `O_RSYNC` in POSIX.
+   *
+   * The precise semantics of this operation have not yet been defined for
+   * WASI. At this time, it should be interpreted as a request, and not a
+   * requirement.
+   */
+  requestedWriteSync?: boolean,
+  /**
+   * Mutating directories mode: Directory contents may be mutated.
+   *
+   * When this flag is unset on a descriptor, operations using the
+   * descriptor which would create, rename, delete, modify the data or
+   * metadata of filesystem objects, or obtain another handle which
+   * would permit any of those, shall fail with `error-code::read-only` if
+   * they would otherwise succeed.
+   *
+   * This may only be set on directories.
+   */
+  mutateDirectory?: boolean,
+}
+/**
+ * Flags determining the method of how paths are resolved.
+ */
+export interface PathFlags {
+  /**
+   * As long as the resolved path corresponds to a symbolic link, it is
+   * expanded.
+   */
+  symlinkFollow?: boolean,
+}
+/**
+ * Open flags used by `open-at`.
+ */
+export interface OpenFlags {
+  /**
+   * Create file if it does not exist, similar to `O_CREAT` in POSIX.
+   */
+  create?: boolean,
+  /**
+   * Fail if not a directory, similar to `O_DIRECTORY` in POSIX.
+   */
+  directory?: boolean,
+  /**
+   * Fail if file already exists, similar to `O_EXCL` in POSIX.
+   */
+  exclusive?: boolean,
+  /**
+   * Truncate file to size 0, similar to `O_TRUNC` in POSIX.
+   */
+  truncate?: boolean,
+}
+/**
+ * Number of hard links to an inode.
+ */
+export type LinkCount = bigint;
+/**
+ * File attributes.
+ *
+ * Note: This was called `filestat` in earlier versions of WASI.
+ */
+export interface DescriptorStat {
+  /**
+   * File type.
+   */
+  type: DescriptorType,
+  /**
+   * Number of hard links to the file.
+   */
+  linkCount: LinkCount,
+  /**
+   * For regular files, the file size in bytes. For symbolic links, the
+   * length in bytes of the pathname contained in the symbolic link.
+   */
+  size: Filesize,
+  /**
+   * Last data access timestamp.
+   *
+   * If the `option` is none, the platform doesn't maintain an access
+   * timestamp for this file.
+   */
+  dataAccessTimestamp?: Datetime,
+  /**
+   * Last data modification timestamp.
+   *
+   * If the `option` is none, the platform doesn't maintain a
+   * modification timestamp for this file.
+   */
+  dataModificationTimestamp?: Datetime,
+  /**
+   * Last file status-change timestamp.
+   *
+   * If the `option` is none, the platform doesn't maintain a
+   * status-change timestamp for this file.
+   */
+  statusChangeTimestamp?: Datetime,
+}
+/**
+ * When setting a timestamp, this gives the value to set it to.
+ */
+export type NewTimestamp = NewTimestampNoChange | NewTimestampNow | NewTimestampTimestamp;
+/**
+ * Leave the timestamp set to its previous value.
+ */
+export interface NewTimestampNoChange {
+  tag: 'no-change',
+}
+/**
+ * Set the timestamp to the current time of the system clock associated
+ * with the filesystem.
+ */
+export interface NewTimestampNow {
+  tag: 'now',
+}
+/**
+ * Set the timestamp to the given value.
+ */
+export interface NewTimestampTimestamp {
+  tag: 'timestamp',
+  val: Datetime,
+}
+/**
+ * A directory entry.
+ */
+export interface DirectoryEntry {
+  /**
+   * The type of the file referred to by this directory entry.
+   */
+  type: DescriptorType,
+  /**
+   * The name of the object.
+   */
+  name: string,
+}
+/**
+ * Error codes returned by functions, similar to `errno` in POSIX.
+ * Not all of these error codes are returned by the functions provided by this
+ * API; some are used in higher-level library layers, and others are provided
+ * merely for alignment with POSIX.
+ * # Variants
+ *
+ * ## `"access"`
+ *
+ * Permission denied, similar to `EACCES` in POSIX.
+ * ## `"would-block"`
+ *
+ * Resource unavailable, or operation would block, similar to `EAGAIN` and `EWOULDBLOCK` in POSIX.
+ * ## `"already"`
+ *
+ * Connection already in progress, similar to `EALREADY` in POSIX.
+ * ## `"bad-descriptor"`
+ *
+ * Bad descriptor, similar to `EBADF` in POSIX.
+ * ## `"busy"`
+ *
+ * Device or resource busy, similar to `EBUSY` in POSIX.
+ * ## `"deadlock"`
+ *
+ * Resource deadlock would occur, similar to `EDEADLK` in POSIX.
+ * ## `"quota"`
+ *
+ * Storage quota exceeded, similar to `EDQUOT` in POSIX.
+ * ## `"exist"`
+ *
+ * File exists, similar to `EEXIST` in POSIX.
+ * ## `"file-too-large"`
+ *
+ * File too large, similar to `EFBIG` in POSIX.
+ * ## `"illegal-byte-sequence"`
+ *
+ * Illegal byte sequence, similar to `EILSEQ` in POSIX.
+ * ## `"in-progress"`
+ *
+ * Operation in progress, similar to `EINPROGRESS` in POSIX.
+ * ## `"interrupted"`
+ *
+ * Interrupted function, similar to `EINTR` in POSIX.
+ * ## `"invalid"`
+ *
+ * Invalid argument, similar to `EINVAL` in POSIX.
+ * ## `"io"`
+ *
+ * I/O error, similar to `EIO` in POSIX.
+ * ## `"is-directory"`
+ *
+ * Is a directory, similar to `EISDIR` in POSIX.
+ * ## `"loop"`
+ *
+ * Too many levels of symbolic links, similar to `ELOOP` in POSIX.
+ * ## `"too-many-links"`
+ *
+ * Too many links, similar to `EMLINK` in POSIX.
+ * ## `"message-size"`
+ *
+ * Message too large, similar to `EMSGSIZE` in POSIX.
+ * ## `"name-too-long"`
+ *
+ * Filename too long, similar to `ENAMETOOLONG` in POSIX.
+ * ## `"no-device"`
+ *
+ * No such device, similar to `ENODEV` in POSIX.
+ * ## `"no-entry"`
+ *
+ * No such file or directory, similar to `ENOENT` in POSIX.
+ * ## `"no-lock"`
+ *
+ * No locks available, similar to `ENOLCK` in POSIX.
+ * ## `"insufficient-memory"`
+ *
+ * Not enough space, similar to `ENOMEM` in POSIX.
+ * ## `"insufficient-space"`
+ *
+ * No space left on device, similar to `ENOSPC` in POSIX.
+ * ## `"not-directory"`
+ *
+ * Not a directory or a symbolic link to a directory, similar to `ENOTDIR` in POSIX.
+ * ## `"not-empty"`
+ *
+ * Directory not empty, similar to `ENOTEMPTY` in POSIX.
+ * ## `"not-recoverable"`
+ *
+ * State not recoverable, similar to `ENOTRECOVERABLE` in POSIX.
+ * ## `"unsupported"`
+ *
+ * Not supported, similar to `ENOTSUP` and `ENOSYS` in POSIX.
+ * ## `"no-tty"`
+ *
+ * Inappropriate I/O control operation, similar to `ENOTTY` in POSIX.
+ * ## `"no-such-device"`
+ *
+ * No such device or address, similar to `ENXIO` in POSIX.
+ * ## `"overflow"`
+ *
+ * Value too large to be stored in data type, similar to `EOVERFLOW` in POSIX.
+ * ## `"not-permitted"`
+ *
+ * Operation not permitted, similar to `EPERM` in POSIX.
+ * ## `"pipe"`
+ *
+ * Broken pipe, similar to `EPIPE` in POSIX.
+ * ## `"read-only"`
+ *
+ * Read-only file system, similar to `EROFS` in POSIX.
+ * ## `"invalid-seek"`
+ *
+ * Invalid seek, similar to `ESPIPE` in POSIX.
+ * ## `"text-file-busy"`
+ *
+ * Text file busy, similar to `ETXTBSY` in POSIX.
+ * ## `"cross-device"`
+ *
+ * Cross-device link, similar to `EXDEV` in POSIX.
+ */
+export type ErrorCode = 'access' | 'would-block' | 'already' | 'bad-descriptor' | 'busy' | 'deadlock' | 'quota' | 'exist' | 'file-too-large' | 'illegal-byte-sequence' | 'in-progress' | 'interrupted' | 'invalid' | 'io' | 'is-directory' | 'loop' | 'too-many-links' | 'message-size' | 'name-too-long' | 'no-device' | 'no-entry' | 'no-lock' | 'insufficient-memory' | 'insufficient-space' | 'not-directory' | 'not-empty' | 'not-recoverable' | 'unsupported' | 'no-tty' | 'no-such-device' | 'overflow' | 'not-permitted' | 'pipe' | 'read-only' | 'invalid-seek' | 'text-file-busy' | 'cross-device';
+/**
+ * File or memory access pattern advisory information.
+ * # Variants
+ *
+ * ## `"normal"`
+ *
+ * The application has no advice to give on its behavior with respect
+ * to the specified data.
+ * ## `"sequential"`
+ *
+ * The application expects to access the specified data sequentially
+ * from lower offsets to higher offsets.
+ * ## `"random"`
+ *
+ * The application expects to access the specified data in a random
+ * order.
+ * ## `"will-need"`
+ *
+ * The application expects to access the specified data in the near
+ * future.
+ * ## `"dont-need"`
+ *
+ * The application expects that it will not access the specified data
+ * in the near future.
+ * ## `"no-reuse"`
+ *
+ * The application expects to access the specified data once and then
+ * not reuse it thereafter.
+ */
+export type Advice = 'normal' | 'sequential' | 'random' | 'will-need' | 'dont-need' | 'no-reuse';
+/**
+ * A 128-bit hash value, split into parts because wasm doesn't have a
+ * 128-bit integer type.
+ */
+export interface MetadataHashValue {
+  /**
+   * 64 bits of a 128-bit hash value.
+   */
+  lower: bigint,
+  /**
+   * Another 64 bits of a 128-bit hash value.
+   */
+  upper: bigint,
+}
+
+export class Descriptor implements Partial<Disposable> {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
+  /**
+  * Return a stream for reading from a file, if available.
+  *
+  * May fail with an error-code describing why the file cannot be read.
+  *
+  * Multiple read, write, and append streams may be active on the same open
+  * file and they do not interfere with each other.
+  *
+  * Note: This allows using `read-stream`, which is similar to `read` in POSIX.
+  */
+  readViaStream(offset: Filesize): InputStream;
+  /**
+  * Return a stream for writing to a file, if available.
+  *
+  * May fail with an error-code describing why the file cannot be written.
+  *
+  * Note: This allows using `write-stream`, which is similar to `write` in
+  * POSIX.
+  */
+  writeViaStream(offset: Filesize): OutputStream;
+  /**
+  * Return a stream for appending to a file, if available.
+  *
+  * May fail with an error-code describing why the file cannot be appended.
+  *
+  * Note: This allows using `write-stream`, which is similar to `write` with
+  * `O_APPEND` in POSIX.
+  */
+  appendViaStream(): OutputStream;
+  /**
+  * Provide file advisory information on a descriptor.
+  *
+  * This is similar to `posix_fadvise` in POSIX.
+  */
+  advise(offset: Filesize, length: Filesize, advice: Advice): void;
+  /**
+  * Synchronize the data of a file to disk.
+  *
+  * This function succeeds with no effect if the file descriptor is not
+  * opened for writing.
+  *
+  * Note: This is similar to `fdatasync` in POSIX.
+  */
+  syncData(): void;
+  /**
+  * Get flags associated with a descriptor.
+  *
+  * Note: This returns similar flags to `fcntl(fd, F_GETFL)` in POSIX.
+  *
+  * Note: This returns the value that was the `fs_flags` value returned
+  * from `fdstat_get` in earlier versions of WASI.
+  */
+  getFlags(): DescriptorFlags;
+  /**
+  * Get the dynamic type of a descriptor.
+  *
+  * Note: This returns the same value as the `type` field of the `fd-stat`
+  * returned by `stat`, `stat-at` and similar.
+  *
+  * Note: This returns similar flags to the `st_mode & S_IFMT` value provided
+  * by `fstat` in POSIX.
+  *
+  * Note: This returns the value that was the `fs_filetype` value returned
+  * from `fdstat_get` in earlier versions of WASI.
+  */
+  getType(): DescriptorType;
+  /**
+  * Adjust the size of an open file. If this increases the file's size, the
+  * extra bytes are filled with zeros.
+  *
+  * Note: This was called `fd_filestat_set_size` in earlier versions of WASI.
+  */
+  setSize(size: Filesize): void;
+  /**
+  * Adjust the timestamps of an open file or directory.
+  *
+  * Note: This is similar to `futimens` in POSIX.
+  *
+  * Note: This was called `fd_filestat_set_times` in earlier versions of WASI.
+  */
+  setTimes(dataAccessTimestamp: NewTimestamp, dataModificationTimestamp: NewTimestamp): void;
+  /**
+  * Read from a descriptor, without using and updating the descriptor's offset.
+  *
+  * This function returns a list of bytes containing the data that was
+  * read, along with a bool which, when true, indicates that the end of the
+  * file was reached. The returned list will contain up to `length` bytes; it
+  * may return fewer than requested, if the end of the file is reached or
+  * if the I/O operation is interrupted.
+  *
+  * In the future, this may change to return a `stream<u8, error-code>`.
+  *
+  * Note: This is similar to `pread` in POSIX.
+  */
+  read(length: Filesize, offset: Filesize): [Uint8Array, boolean];
+  /**
+  * Write to a descriptor, without using and updating the descriptor's offset.
+  *
+  * It is valid to write past the end of a file; the file is extended to the
+  * extent of the write, with bytes between the previous end and the start of
+  * the write set to zero.
+  *
+  * In the future, this may change to take a `stream<u8, error-code>`.
+  *
+  * Note: This is similar to `pwrite` in POSIX.
+  */
+  write(buffer: Uint8Array, offset: Filesize): Filesize;
+  /**
+  * Read directory entries from a directory.
+  *
+  * On filesystems where directories contain entries referring to themselves
+  * and their parents, often named `.` and `..` respectively, these entries
+  * are omitted.
+  *
+  * This always returns a new stream which starts at the beginning of the
+  * directory. Multiple streams may be active on the same directory, and they
+  * do not interfere with each other.
+  */
+  readDirectory(): DirectoryEntryStream;
+  /**
+  * Synchronize the data and metadata of a file to disk.
+  *
+  * This function succeeds with no effect if the file descriptor is not
+  * opened for writing.
+  *
+  * Note: This is similar to `fsync` in POSIX.
+  */
+  sync(): void;
+  /**
+  * Create a directory.
+  *
+  * Note: This is similar to `mkdirat` in POSIX.
+  */
+  createDirectoryAt(path: string): void;
+  /**
+  * Return the attributes of an open file or directory.
+  *
+  * Note: This is similar to `fstat` in POSIX, except that it does not return
+  * device and inode information. For testing whether two descriptors refer to
+  * the same underlying filesystem object, use `is-same-object`. To obtain
+  * additional data that can be used do determine whether a file has been
+  * modified, use `metadata-hash`.
+  *
+  * Note: This was called `fd_filestat_get` in earlier versions of WASI.
+  */
+  stat(): DescriptorStat;
+  /**
+  * Return the attributes of a file or directory.
+  *
+  * Note: This is similar to `fstatat` in POSIX, except that it does not
+  * return device and inode information. See the `stat` description for a
+  * discussion of alternatives.
+  *
+  * Note: This was called `path_filestat_get` in earlier versions of WASI.
+  */
+  statAt(pathFlags: PathFlags, path: string): DescriptorStat;
+  /**
+  * Adjust the timestamps of a file or directory.
+  *
+  * Note: This is similar to `utimensat` in POSIX.
+  *
+  * Note: This was called `path_filestat_set_times` in earlier versions of
+  * WASI.
+  */
+  setTimesAt(pathFlags: PathFlags, path: string, dataAccessTimestamp: NewTimestamp, dataModificationTimestamp: NewTimestamp): void;
+  /**
+  * Create a hard link.
+  *
+  * Note: This is similar to `linkat` in POSIX.
+  */
+  linkAt(oldPathFlags: PathFlags, oldPath: string, newDescriptor: Descriptor, newPath: string): void;
+  /**
+  * Open a file or directory.
+  *
+  * If `flags` contains `descriptor-flags::mutate-directory`, and the base
+  * descriptor doesn't have `descriptor-flags::mutate-directory` set,
+  * `open-at` fails with `error-code::read-only`.
+  *
+  * If `flags` contains `write` or `mutate-directory`, or `open-flags`
+  * contains `truncate` or `create`, and the base descriptor doesn't have
+  * `descriptor-flags::mutate-directory` set, `open-at` fails with
+  * `error-code::read-only`.
+  *
+  * Note: This is similar to `openat` in POSIX.
+  */
+  openAt(pathFlags: PathFlags, path: string, openFlags: OpenFlags, flags: DescriptorFlags): Descriptor;
+  /**
+  * Read the contents of a symbolic link.
+  *
+  * If the contents contain an absolute or rooted path in the underlying
+  * filesystem, this function fails with `error-code::not-permitted`.
+  *
+  * Note: This is similar to `readlinkat` in POSIX.
+  */
+  readlinkAt(path: string): string;
+  /**
+  * Remove a directory.
+  *
+  * Return `error-code::not-empty` if the directory is not empty.
+  *
+  * Note: This is similar to `unlinkat(fd, path, AT_REMOVEDIR)` in POSIX.
+  */
+  removeDirectoryAt(path: string): void;
+  /**
+  * Rename a filesystem object.
+  *
+  * Note: This is similar to `renameat` in POSIX.
+  */
+  renameAt(oldPath: string, newDescriptor: Descriptor, newPath: string): void;
+  /**
+  * Create a symbolic link (also known as a "symlink").
+  *
+  * If `old-path` starts with `/`, the function fails with
+  * `error-code::not-permitted`.
+  *
+  * Note: This is similar to `symlinkat` in POSIX.
+  */
+  symlinkAt(oldPath: string, newPath: string): void;
+  /**
+  * Unlink a filesystem object that is not a directory.
+  *
+  * Return `error-code::is-directory` if the path refers to a directory.
+  * Note: This is similar to `unlinkat(fd, path, 0)` in POSIX.
+  */
+  unlinkFileAt(path: string): void;
+  /**
+  * Test whether two descriptors refer to the same filesystem object.
+  *
+  * In POSIX, this corresponds to testing whether the two descriptors have the
+  * same device (`st_dev`) and inode (`st_ino` or `d_ino`) numbers.
+  * wasi-filesystem does not expose device and inode numbers, so this function
+  * may be used instead.
+  */
+  isSameObject(other: Descriptor): boolean;
+  /**
+  * Return a hash of the metadata associated with a filesystem object referred
+  * to by a descriptor.
+  *
+  * This returns a hash of the last-modification timestamp and file size, and
+  * may also include the inode number, device number, birth timestamp, and
+  * other metadata fields that may change when the file is modified or
+  * replaced. It may also include a secret value chosen by the
+  * implementation and not otherwise exposed.
+  *
+  * Implementations are encouraged to provide the following properties:
+  *
+  *  - If the file is not modified or replaced, the computed hash value should
+  *    usually not change.
+  *  - If the object is modified or replaced, the computed hash value should
+  *    usually change.
+  *  - The inputs to the hash should not be easily computable from the
+  *    computed hash.
+  *
+  * However, none of these is required.
+  */
+  metadataHash(): MetadataHashValue;
+  /**
+  * Return a hash of the metadata associated with a filesystem object referred
+  * to by a directory descriptor and a relative path.
+  *
+  * This performs the same hash computation as `metadata-hash`.
+  */
+  metadataHashAt(pathFlags: PathFlags, path: string): MetadataHashValue;
+    [Symbol.dispose]?: () => void;
+}
+
+export class DirectoryEntryStream implements Partial<Disposable> {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
+  /**
+  * Read a single directory entry from a `directory-entry-stream`.
+  */
+  readDirectoryEntry(): DirectoryEntry | undefined;
+    [Symbol.dispose]?: () => void;
+}

guests/typescript/generated/types/interfaces/wasi-http-incoming-handler.d.ts

@@ -0,0 +1,16 @@
+/** @module Interface wasi:http/incoming-handler@0.2.3 **/
+/**
+ * This function is invoked with an incoming HTTP Request, and a resource
+ * `response-outparam` which provides the capability to reply with an HTTP
+ * Response. The response is sent by calling the `response-outparam.set`
+ * method, which allows execution to continue after the response has been
+ * sent. This enables both streaming to the response body, and performing other
+ * work.
+ *
+ * The implementor of this function must write a response to the
+ * `response-outparam` before returning, or else the caller will respond
+ * with an error on its behalf.
+ */
+export function handle(request: IncomingRequest, responseOut: ResponseOutparam): void;
+export type IncomingRequest = import('./wasi-http-types.js').IncomingRequest;
+export type ResponseOutparam = import('./wasi-http-types.js').ResponseOutparam;

guests/typescript/generated/types/interfaces/wasi-http-outgoing-handler.d.ts

@@ -0,0 +1,18 @@
+/** @module Interface wasi:http/outgoing-handler@0.2.3 **/
+/**
+ * This function is invoked with an outgoing HTTP Request, and it returns
+ * a resource `future-incoming-response` which represents an HTTP Response
+ * which may arrive in the future.
+ *
+ * The `options` argument accepts optional parameters for the HTTP
+ * protocol's transport layer.
+ *
+ * This function may return an error if the `outgoing-request` is invalid
+ * or not allowed to be made. Otherwise, protocol errors are reported
+ * through the `future-incoming-response`.
+ */
+export function handle(request: OutgoingRequest, options: RequestOptions | undefined): FutureIncomingResponse;
+export type OutgoingRequest = import('./wasi-http-types.js').OutgoingRequest;
+export type RequestOptions = import('./wasi-http-types.js').RequestOptions;
+export type FutureIncomingResponse = import('./wasi-http-types.js').FutureIncomingResponse;
+export type ErrorCode = import('./wasi-http-types.js').ErrorCode;

guests/typescript/generated/types/interfaces/wasi-http-types.d.ts

@@ -0,0 +1,759 @@
+/** @module Interface wasi:http/types@0.2.3 **/
+/**
+ * Attempts to extract a http-related `error` from the wasi:io `error`
+ * provided.
+ *
+ * Stream operations which return
+ * `wasi:io/stream/stream-error::last-operation-failed` have a payload of
+ * type `wasi:io/error/error` with more information about the operation
+ * that failed. This payload can be passed through to this function to see
+ * if there's http-related information about the error to return.
+ *
+ * Note that this function is fallible because not all io-errors are
+ * http-related errors.
+ */
+export function httpErrorCode(err: IoError): ErrorCode | undefined;
+export type Duration = import('./wasi-clocks-monotonic-clock.js').Duration;
+export type InputStream = import('./wasi-io-streams.js').InputStream;
+export type OutputStream = import('./wasi-io-streams.js').OutputStream;
+export type IoError = import('./wasi-io-error.js').Error;
+export type Pollable = import('./wasi-io-poll.js').Pollable;
+/**
+ * This type corresponds to HTTP standard Methods.
+ */
+export type Method = MethodGet | MethodHead | MethodPost | MethodPut | MethodDelete | MethodConnect | MethodOptions | MethodTrace | MethodPatch | MethodOther;
+export interface MethodGet {
+  tag: 'get',
+}
+export interface MethodHead {
+  tag: 'head',
+}
+export interface MethodPost {
+  tag: 'post',
+}
+export interface MethodPut {
+  tag: 'put',
+}
+export interface MethodDelete {
+  tag: 'delete',
+}
+export interface MethodConnect {
+  tag: 'connect',
+}
+export interface MethodOptions {
+  tag: 'options',
+}
+export interface MethodTrace {
+  tag: 'trace',
+}
+export interface MethodPatch {
+  tag: 'patch',
+}
+export interface MethodOther {
+  tag: 'other',
+  val: string,
+}
+/**
+ * This type corresponds to HTTP standard Related Schemes.
+ */
+export type Scheme = SchemeHttp | SchemeHttps | SchemeOther;
+export interface SchemeHttp {
+  tag: 'HTTP',
+}
+export interface SchemeHttps {
+  tag: 'HTTPS',
+}
+export interface SchemeOther {
+  tag: 'other',
+  val: string,
+}
+/**
+ * Defines the case payload type for `DNS-error` above:
+ */
+export interface DnsErrorPayload {
+  rcode?: string,
+  infoCode?: number,
+}
+/**
+ * Defines the case payload type for `TLS-alert-received` above:
+ */
+export interface TlsAlertReceivedPayload {
+  alertId?: number,
+  alertMessage?: string,
+}
+/**
+ * Defines the case payload type for `HTTP-response-{header,trailer}-size` above:
+ */
+export interface FieldSizePayload {
+  fieldName?: string,
+  fieldSize?: number,
+}
+/**
+ * These cases are inspired by the IANA HTTP Proxy Error Types:
+ *   <https://www.iana.org/assignments/http-proxy-status/http-proxy-status.xhtml#table-http-proxy-error-types>
+ */
+export type ErrorCode = ErrorCodeDnsTimeout | ErrorCodeDnsError | ErrorCodeDestinationNotFound | ErrorCodeDestinationUnavailable | ErrorCodeDestinationIpProhibited | ErrorCodeDestinationIpUnroutable | ErrorCodeConnectionRefused | ErrorCodeConnectionTerminated | ErrorCodeConnectionTimeout | ErrorCodeConnectionReadTimeout | ErrorCodeConnectionWriteTimeout | ErrorCodeConnectionLimitReached | ErrorCodeTlsProtocolError | ErrorCodeTlsCertificateError | ErrorCodeTlsAlertReceived | ErrorCodeHttpRequestDenied | ErrorCodeHttpRequestLengthRequired | ErrorCodeHttpRequestBodySize | ErrorCodeHttpRequestMethodInvalid | ErrorCodeHttpRequestUriInvalid | ErrorCodeHttpRequestUriTooLong | ErrorCodeHttpRequestHeaderSectionSize | ErrorCodeHttpRequestHeaderSize | ErrorCodeHttpRequestTrailerSectionSize | ErrorCodeHttpRequestTrailerSize | ErrorCodeHttpResponseIncomplete | ErrorCodeHttpResponseHeaderSectionSize | ErrorCodeHttpResponseHeaderSize | ErrorCodeHttpResponseBodySize | ErrorCodeHttpResponseTrailerSectionSize | ErrorCodeHttpResponseTrailerSize | ErrorCodeHttpResponseTransferCoding | ErrorCodeHttpResponseContentCoding | ErrorCodeHttpResponseTimeout | ErrorCodeHttpUpgradeFailed | ErrorCodeHttpProtocolError | ErrorCodeLoopDetected | ErrorCodeConfigurationError | ErrorCodeInternalError;
+export interface ErrorCodeDnsTimeout {
+  tag: 'DNS-timeout',
+}
+export interface ErrorCodeDnsError {
+  tag: 'DNS-error',
+  val: DnsErrorPayload,
+}
+export interface ErrorCodeDestinationNotFound {
+  tag: 'destination-not-found',
+}
+export interface ErrorCodeDestinationUnavailable {
+  tag: 'destination-unavailable',
+}
+export interface ErrorCodeDestinationIpProhibited {
+  tag: 'destination-IP-prohibited',
+}
+export interface ErrorCodeDestinationIpUnroutable {
+  tag: 'destination-IP-unroutable',
+}
+export interface ErrorCodeConnectionRefused {
+  tag: 'connection-refused',
+}
+export interface ErrorCodeConnectionTerminated {
+  tag: 'connection-terminated',
+}
+export interface ErrorCodeConnectionTimeout {
+  tag: 'connection-timeout',
+}
+export interface ErrorCodeConnectionReadTimeout {
+  tag: 'connection-read-timeout',
+}
+export interface ErrorCodeConnectionWriteTimeout {
+  tag: 'connection-write-timeout',
+}
+export interface ErrorCodeConnectionLimitReached {
+  tag: 'connection-limit-reached',
+}
+export interface ErrorCodeTlsProtocolError {
+  tag: 'TLS-protocol-error',
+}
+export interface ErrorCodeTlsCertificateError {
+  tag: 'TLS-certificate-error',
+}
+export interface ErrorCodeTlsAlertReceived {
+  tag: 'TLS-alert-received',
+  val: TlsAlertReceivedPayload,
+}
+export interface ErrorCodeHttpRequestDenied {
+  tag: 'HTTP-request-denied',
+}
+export interface ErrorCodeHttpRequestLengthRequired {
+  tag: 'HTTP-request-length-required',
+}
+export interface ErrorCodeHttpRequestBodySize {
+  tag: 'HTTP-request-body-size',
+  val: bigint | undefined,
+}
+export interface ErrorCodeHttpRequestMethodInvalid {
+  tag: 'HTTP-request-method-invalid',
+}
+export interface ErrorCodeHttpRequestUriInvalid {
+  tag: 'HTTP-request-URI-invalid',
+}
+export interface ErrorCodeHttpRequestUriTooLong {
+  tag: 'HTTP-request-URI-too-long',
+}
+export interface ErrorCodeHttpRequestHeaderSectionSize {
+  tag: 'HTTP-request-header-section-size',
+  val: number | undefined,
+}
+export interface ErrorCodeHttpRequestHeaderSize {
+  tag: 'HTTP-request-header-size',
+  val: FieldSizePayload | undefined,
+}
+export interface ErrorCodeHttpRequestTrailerSectionSize {
+  tag: 'HTTP-request-trailer-section-size',
+  val: number | undefined,
+}
+export interface ErrorCodeHttpRequestTrailerSize {
+  tag: 'HTTP-request-trailer-size',
+  val: FieldSizePayload,
+}
+export interface ErrorCodeHttpResponseIncomplete {
+  tag: 'HTTP-response-incomplete',
+}
+export interface ErrorCodeHttpResponseHeaderSectionSize {
+  tag: 'HTTP-response-header-section-size',
+  val: number | undefined,
+}
+export interface ErrorCodeHttpResponseHeaderSize {
+  tag: 'HTTP-response-header-size',
+  val: FieldSizePayload,
+}
+export interface ErrorCodeHttpResponseBodySize {
+  tag: 'HTTP-response-body-size',
+  val: bigint | undefined,
+}
+export interface ErrorCodeHttpResponseTrailerSectionSize {
+  tag: 'HTTP-response-trailer-section-size',
+  val: number | undefined,
+}
+export interface ErrorCodeHttpResponseTrailerSize {
+  tag: 'HTTP-response-trailer-size',
+  val: FieldSizePayload,
+}
+export interface ErrorCodeHttpResponseTransferCoding {
+  tag: 'HTTP-response-transfer-coding',
+  val: string | undefined,
+}
+export interface ErrorCodeHttpResponseContentCoding {
+  tag: 'HTTP-response-content-coding',
+  val: string | undefined,
+}
+export interface ErrorCodeHttpResponseTimeout {
+  tag: 'HTTP-response-timeout',
+}
+export interface ErrorCodeHttpUpgradeFailed {
+  tag: 'HTTP-upgrade-failed',
+}
+export interface ErrorCodeHttpProtocolError {
+  tag: 'HTTP-protocol-error',
+}
+export interface ErrorCodeLoopDetected {
+  tag: 'loop-detected',
+}
+export interface ErrorCodeConfigurationError {
+  tag: 'configuration-error',
+}
+/**
+ * This is a catch-all error for anything that doesn't fit cleanly into a
+ * more specific case. It also includes an optional string for an
+ * unstructured description of the error. Users should not depend on the
+ * string for diagnosing errors, as it's not required to be consistent
+ * between implementations.
+ */
+export interface ErrorCodeInternalError {
+  tag: 'internal-error',
+  val: string | undefined,
+}
+/**
+ * This type enumerates the different kinds of errors that may occur when
+ * setting or appending to a `fields` resource.
+ */
+export type HeaderError = HeaderErrorInvalidSyntax | HeaderErrorForbidden | HeaderErrorImmutable;
+/**
+ * This error indicates that a `field-name` or `field-value` was
+ * syntactically invalid when used with an operation that sets headers in a
+ * `fields`.
+ */
+export interface HeaderErrorInvalidSyntax {
+  tag: 'invalid-syntax',
+}
+/**
+ * This error indicates that a forbidden `field-name` was used when trying
+ * to set a header in a `fields`.
+ */
+export interface HeaderErrorForbidden {
+  tag: 'forbidden',
+}
+/**
+ * This error indicates that the operation on the `fields` was not
+ * permitted because the fields are immutable.
+ */
+export interface HeaderErrorImmutable {
+  tag: 'immutable',
+}
+/**
+ * Field keys are always strings.
+ *
+ * Field keys should always be treated as case insensitive by the `fields`
+ * resource for the purposes of equality checking.
+ *
+ * # Deprecation
+ *
+ * This type has been deprecated in favor of the `field-name` type.
+ */
+export type FieldKey = string;
+/**
+ * Field names are always strings.
+ *
+ * Field names should always be treated as case insensitive by the `fields`
+ * resource for the purposes of equality checking.
+ */
+export type FieldName = FieldKey;
+/**
+ * Field values should always be ASCII strings. However, in
+ * reality, HTTP implementations often have to interpret malformed values,
+ * so they are provided as a list of bytes.
+ */
+export type FieldValue = Uint8Array;
+/**
+ * Headers is an alias for Fields.
+ */
+export type Headers = Fields;
+/**
+ * Trailers is an alias for Fields.
+ */
+export type Trailers = Fields;
+/**
+ * This type corresponds to the HTTP standard Status Code.
+ */
+export type StatusCode = number;
+export type Result<T, E> = { tag: 'ok', val: T } | { tag: 'err', val: E };
+
+export class Fields implements Partial<Disposable> {
+  /**
+  * Construct an empty HTTP Fields.
+  *
+  * The resulting `fields` is mutable.
+  */
+  constructor()
+  /**
+  * Construct an HTTP Fields.
+  *
+  * The resulting `fields` is mutable.
+  *
+  * The list represents each name-value pair in the Fields. Names
+  * which have multiple values are represented by multiple entries in this
+  * list with the same name.
+  *
+  * The tuple is a pair of the field name, represented as a string, and
+  * Value, represented as a list of bytes.
+  *
+  * An error result will be returned if any `field-name` or `field-value` is
+  * syntactically invalid, or if a field is forbidden.
+  */
+  static fromList(entries: Array<[FieldName, FieldValue]>): Fields;
+  /**
+  * Get all of the values corresponding to a name. If the name is not present
+  * in this `fields` or is syntactically invalid, an empty list is returned.
+  * However, if the name is present but empty, this is represented by a list
+  * with one or more empty field-values present.
+  */
+  get(name: FieldName): Array<FieldValue>;
+  /**
+  * Returns `true` when the name is present in this `fields`. If the name is
+  * syntactically invalid, `false` is returned.
+  */
+  has(name: FieldName): boolean;
+  /**
+  * Set all of the values for a name. Clears any existing values for that
+  * name, if they have been set.
+  *
+  * Fails with `header-error.immutable` if the `fields` are immutable.
+  *
+  * Fails with `header-error.invalid-syntax` if the `field-name` or any of
+  * the `field-value`s are syntactically invalid.
+  */
+  set(name: FieldName, value: Array<FieldValue>): void;
+  /**
+  * Delete all values for a name. Does nothing if no values for the name
+  * exist.
+  *
+  * Fails with `header-error.immutable` if the `fields` are immutable.
+  *
+  * Fails with `header-error.invalid-syntax` if the `field-name` is
+  * syntactically invalid.
+  */
+  'delete'(name: FieldName): void;
+  /**
+  * Append a value for a name. Does not change or delete any existing
+  * values for that name.
+  *
+  * Fails with `header-error.immutable` if the `fields` are immutable.
+  *
+  * Fails with `header-error.invalid-syntax` if the `field-name` or
+  * `field-value` are syntactically invalid.
+  */
+  append(name: FieldName, value: FieldValue): void;
+  /**
+  * Retrieve the full set of names and values in the Fields. Like the
+  * constructor, the list represents each name-value pair.
+  *
+  * The outer list represents each name-value pair in the Fields. Names
+  * which have multiple values are represented by multiple entries in this
+  * list with the same name.
+  *
+  * The names and values are always returned in the original casing and in
+  * the order in which they will be serialized for transport.
+  */
+  entries(): Array<[FieldName, FieldValue]>;
+  /**
+  * Make a deep copy of the Fields. Equivalent in behavior to calling the
+  * `fields` constructor on the return value of `entries`. The resulting
+  * `fields` is mutable.
+  */
+  clone(): Fields;
+    [Symbol.dispose]?: () => void;
+}
+
+export class FutureIncomingResponse implements Partial<Disposable> {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
+  /**
+  * Returns a pollable which becomes ready when either the Response has
+  * been received, or an error has occurred. When this pollable is ready,
+  * the `get` method will return `some`.
+  */
+  subscribe(): Pollable;
+  /**
+  * Returns the incoming HTTP Response, or an error, once one is ready.
+  *
+  * The outer `option` represents future readiness. Users can wait on this
+  * `option` to become `some` using the `subscribe` method.
+  *
+  * The outer `result` is used to retrieve the response or error at most
+  * once. It will be success on the first call in which the outer option
+  * is `some`, and error on subsequent calls.
+  *
+  * The inner `result` represents that either the incoming HTTP Response
+  * status and headers have received successfully, or that an error
+  * occurred. Errors may also occur while consuming the response body,
+  * but those will be reported by the `incoming-body` and its
+  * `output-stream` child.
+  */
+  get(): Result<Result<IncomingResponse, ErrorCode>, void> | undefined;
+    [Symbol.dispose]?: () => void;
+}
+
+export class FutureTrailers implements Partial<Disposable> {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
+  /**
+  * Returns a pollable which becomes ready when either the trailers have
+  * been received, or an error has occurred. When this pollable is ready,
+  * the `get` method will return `some`.
+  */
+  subscribe(): Pollable;
+  /**
+  * Returns the contents of the trailers, or an error which occurred,
+  * once the future is ready.
+  *
+  * The outer `option` represents future readiness. Users can wait on this
+  * `option` to become `some` using the `subscribe` method.
+  *
+  * The outer `result` is used to retrieve the trailers or error at most
+  * once. It will be success on the first call in which the outer option
+  * is `some`, and error on subsequent calls.
+  *
+  * The inner `result` represents that either the HTTP Request or Response
+  * body, as well as any trailers, were received successfully, or that an
+  * error occurred receiving them. The optional `trailers` indicates whether
+  * or not trailers were present in the body.
+  *
+  * When some `trailers` are returned by this method, the `trailers`
+  * resource is immutable, and a child. Use of the `set`, `append`, or
+  * `delete` methods will return an error, and the resource must be
+  * dropped before the parent `future-trailers` is dropped.
+  */
+  get(): Result<Result<Trailers | undefined, ErrorCode>, void> | undefined;
+    [Symbol.dispose]?: () => void;
+}
+
+export class IncomingBody implements Partial<Disposable> {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
+  /**
+  * Returns the contents of the body, as a stream of bytes.
+  *
+  * Returns success on first call: the stream representing the contents
+  * can be retrieved at most once. Subsequent calls will return error.
+  *
+  * The returned `input-stream` resource is a child: it must be dropped
+  * before the parent `incoming-body` is dropped, or consumed by
+  * `incoming-body.finish`.
+  *
+  * This invariant ensures that the implementation can determine whether
+  * the user is consuming the contents of the body, waiting on the
+  * `future-trailers` to be ready, or neither. This allows for network
+  * backpressure is to be applied when the user is consuming the body,
+  * and for that backpressure to not inhibit delivery of the trailers if
+  * the user does not read the entire body.
+  */
+  stream(): InputStream;
+  /**
+  * Takes ownership of `incoming-body`, and returns a `future-trailers`.
+  * This function will trap if the `input-stream` child is still alive.
+  */
+  static finish(this_: IncomingBody): FutureTrailers;
+    [Symbol.dispose]?: () => void;
+}
+
+export class IncomingRequest implements Partial<Disposable> {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
+  /**
+  * Returns the method of the incoming request.
+  */
+  method(): Method;
+  /**
+  * Returns the path with query parameters from the request, as a string.
+  */
+  pathWithQuery(): string | undefined;
+  /**
+  * Returns the protocol scheme from the request.
+  */
+  scheme(): Scheme | undefined;
+  /**
+  * Returns the authority of the Request's target URI, if present.
+  */
+  authority(): string | undefined;
+  /**
+  * Get the `headers` associated with the request.
+  *
+  * The returned `headers` resource is immutable: `set`, `append`, and
+  * `delete` operations will fail with `header-error.immutable`.
+  *
+  * The `headers` returned are a child resource: it must be dropped before
+  * the parent `incoming-request` is dropped. Dropping this
+  * `incoming-request` before all children are dropped will trap.
+  */
+  headers(): Headers;
+  /**
+  * Gives the `incoming-body` associated with this request. Will only
+  * return success at most once, and subsequent calls will return error.
+  */
+  consume(): IncomingBody;
+    [Symbol.dispose]?: () => void;
+}
+
+export class IncomingResponse implements Partial<Disposable> {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
+  /**
+  * Returns the status code from the incoming response.
+  */
+  status(): StatusCode;
+  /**
+  * Returns the headers from the incoming response.
+  *
+  * The returned `headers` resource is immutable: `set`, `append`, and
+  * `delete` operations will fail with `header-error.immutable`.
+  *
+  * This headers resource is a child: it must be dropped before the parent
+  * `incoming-response` is dropped.
+  */
+  headers(): Headers;
+  /**
+  * Returns the incoming body. May be called at most once. Returns error
+  * if called additional times.
+  */
+  consume(): IncomingBody;
+    [Symbol.dispose]?: () => void;
+}
+
+export class OutgoingBody implements Partial<Disposable> {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
+  /**
+  * Returns a stream for writing the body contents.
+  *
+  * The returned `output-stream` is a child resource: it must be dropped
+  * before the parent `outgoing-body` resource is dropped (or finished),
+  * otherwise the `outgoing-body` drop or `finish` will trap.
+  *
+  * Returns success on the first call: the `output-stream` resource for
+  * this `outgoing-body` may be retrieved at most once. Subsequent calls
+  * will return error.
+  */
+  write(): OutputStream;
+  /**
+  * Finalize an outgoing body, optionally providing trailers. This must be
+  * called to signal that the response is complete. If the `outgoing-body`
+  * is dropped without calling `outgoing-body.finalize`, the implementation
+  * should treat the body as corrupted.
+  *
+  * Fails if the body's `outgoing-request` or `outgoing-response` was
+  * constructed with a Content-Length header, and the contents written
+  * to the body (via `write`) does not match the value given in the
+  * Content-Length.
+  */
+  static finish(this_: OutgoingBody, trailers: Trailers | undefined): void;
+    [Symbol.dispose]?: () => void;
+}
+
+export class OutgoingRequest implements Partial<Disposable> {
+  /**
+  * Construct a new `outgoing-request` with a default `method` of `GET`, and
+  * `none` values for `path-with-query`, `scheme`, and `authority`.
+  *
+  * * `headers` is the HTTP Headers for the Request.
+  *
+  * It is possible to construct, or manipulate with the accessor functions
+  * below, an `outgoing-request` with an invalid combination of `scheme`
+  * and `authority`, or `headers` which are not permitted to be sent.
+  * It is the obligation of the `outgoing-handler.handle` implementation
+  * to reject invalid constructions of `outgoing-request`.
+  */
+  constructor(headers: Headers)
+  /**
+  * Returns the resource corresponding to the outgoing Body for this
+  * Request.
+  *
+  * Returns success on the first call: the `outgoing-body` resource for
+  * this `outgoing-request` can be retrieved at most once. Subsequent
+  * calls will return error.
+  */
+  body(): OutgoingBody;
+  /**
+  * Get the Method for the Request.
+  */
+  method(): Method;
+  /**
+  * Set the Method for the Request. Fails if the string present in a
+  * `method.other` argument is not a syntactically valid method.
+  */
+  setMethod(method: Method): void;
+  /**
+  * Get the combination of the HTTP Path and Query for the Request.
+  * When `none`, this represents an empty Path and empty Query.
+  */
+  pathWithQuery(): string | undefined;
+  /**
+  * Set the combination of the HTTP Path and Query for the Request.
+  * When `none`, this represents an empty Path and empty Query. Fails is the
+  * string given is not a syntactically valid path and query uri component.
+  */
+  setPathWithQuery(pathWithQuery: string | undefined): void;
+  /**
+  * Get the HTTP Related Scheme for the Request. When `none`, the
+  * implementation may choose an appropriate default scheme.
+  */
+  scheme(): Scheme | undefined;
+  /**
+  * Set the HTTP Related Scheme for the Request. When `none`, the
+  * implementation may choose an appropriate default scheme. Fails if the
+  * string given is not a syntactically valid uri scheme.
+  */
+  setScheme(scheme: Scheme | undefined): void;
+  /**
+  * Get the authority of the Request's target URI. A value of `none` may be used
+  * with Related Schemes which do not require an authority. The HTTP and
+  * HTTPS schemes always require an authority.
+  */
+  authority(): string | undefined;
+  /**
+  * Set the authority of the Request's target URI. A value of `none` may be used
+  * with Related Schemes which do not require an authority. The HTTP and
+  * HTTPS schemes always require an authority. Fails if the string given is
+  * not a syntactically valid URI authority.
+  */
+  setAuthority(authority: string | undefined): void;
+  /**
+  * Get the headers associated with the Request.
+  *
+  * The returned `headers` resource is immutable: `set`, `append`, and
+  * `delete` operations will fail with `header-error.immutable`.
+  *
+  * This headers resource is a child: it must be dropped before the parent
+  * `outgoing-request` is dropped, or its ownership is transferred to
+  * another component by e.g. `outgoing-handler.handle`.
+  */
+  headers(): Headers;
+    [Symbol.dispose]?: () => void;
+}
+
+export class OutgoingResponse implements Partial<Disposable> {
+  /**
+  * Construct an `outgoing-response`, with a default `status-code` of `200`.
+  * If a different `status-code` is needed, it must be set via the
+  * `set-status-code` method.
+  *
+  * * `headers` is the HTTP Headers for the Response.
+  */
+  constructor(headers: Headers)
+  /**
+  * Get the HTTP Status Code for the Response.
+  */
+  statusCode(): StatusCode;
+  /**
+  * Set the HTTP Status Code for the Response. Fails if the status-code
+  * given is not a valid http status code.
+  */
+  setStatusCode(statusCode: StatusCode): void;
+  /**
+  * Get the headers associated with the Request.
+  *
+  * The returned `headers` resource is immutable: `set`, `append`, and
+  * `delete` operations will fail with `header-error.immutable`.
+  *
+  * This headers resource is a child: it must be dropped before the parent
+  * `outgoing-request` is dropped, or its ownership is transferred to
+  * another component by e.g. `outgoing-handler.handle`.
+  */
+  headers(): Headers;
+  /**
+  * Returns the resource corresponding to the outgoing Body for this Response.
+  *
+  * Returns success on the first call: the `outgoing-body` resource for
+  * this `outgoing-response` can be retrieved at most once. Subsequent
+  * calls will return error.
+  */
+  body(): OutgoingBody;
+    [Symbol.dispose]?: () => void;
+}
+
+export class RequestOptions implements Partial<Disposable> {
+  /**
+  * Construct a default `request-options` value.
+  */
+  constructor()
+  /**
+  * The timeout for the initial connect to the HTTP Server.
+  */
+  connectTimeout(): Duration | undefined;
+  /**
+  * Set the timeout for the initial connect to the HTTP Server. An error
+  * return value indicates that this timeout is not supported.
+  */
+  setConnectTimeout(duration: Duration | undefined): void;
+  /**
+  * The timeout for receiving the first byte of the Response body.
+  */
+  firstByteTimeout(): Duration | undefined;
+  /**
+  * Set the timeout for receiving the first byte of the Response body. An
+  * error return value indicates that this timeout is not supported.
+  */
+  setFirstByteTimeout(duration: Duration | undefined): void;
+  /**
+  * The timeout for receiving subsequent chunks of bytes in the Response
+  * body stream.
+  */
+  betweenBytesTimeout(): Duration | undefined;
+  /**
+  * Set the timeout for receiving subsequent chunks of bytes in the Response
+  * body stream. An error return value indicates that this timeout is not
+  * supported.
+  */
+  setBetweenBytesTimeout(duration: Duration | undefined): void;
+    [Symbol.dispose]?: () => void;
+}
+
+export class ResponseOutparam implements Partial<Disposable> {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
+  /**
+  * Set the value of the `response-outparam` to either send a response,
+  * or indicate an error.
+  *
+  * This method consumes the `response-outparam` to ensure that it is
+  * called at most once. If it is never called, the implementation
+  * will respond with an error.
+  *
+  * The user may provide an `error` to `response` to allow the
+  * implementation determine how to respond with an HTTP error response.
+  */
+  static set(param: ResponseOutparam, response: Result<OutgoingResponse, ErrorCode>): void;
+    [Symbol.dispose]?: () => void;
+}

guests/typescript/generated/types/interfaces/wasi-io-error.d.ts

@@ -0,0 +1,19 @@
+/** @module Interface wasi:io/error@0.2.3 **/
+
+export class Error implements Partial<Disposable> {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
+  /**
+  * Returns a string that is suitable to assist humans in debugging
+  * this error.
+  *
+  * WARNING: The returned string should not be consumed mechanically!
+  * It may change across platforms, hosts, or other implementation
+  * details. Parsing this string is a major platform-compatibility
+  * hazard.
+  */
+  toDebugString(): string;
+    [Symbol.dispose]?: () => void;
+}

guests/typescript/generated/types/interfaces/wasi-io-poll.d.ts

@@ -0,0 +1,45 @@
+/** @module Interface wasi:io/poll@0.2.3 **/
+/**
+ * Poll for completion on a set of pollables.
+ *
+ * This function takes a list of pollables, which identify I/O sources of
+ * interest, and waits until one or more of the events is ready for I/O.
+ *
+ * The result `list<u32>` contains one or more indices of handles in the
+ * argument list that is ready for I/O.
+ *
+ * This function traps if either:
+ * - the list is empty, or:
+ * - the list contains more elements than can be indexed with a `u32` value.
+ *
+ * A timeout can be implemented by adding a pollable from the
+ * wasi-clocks API to the list.
+ *
+ * This function does not return a `result`; polling in itself does not
+ * do any I/O so it doesn't fail. If any of the I/O sources identified by
+ * the pollables has an error, it is indicated by marking the source as
+ * being ready for I/O.
+ */
+export function poll(in_: Array<Pollable>): Uint32Array;
+
+export class Pollable implements Partial<Disposable> {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
+  /**
+  * Return the readiness of a pollable. This function never blocks.
+  *
+  * Returns `true` when the pollable is ready, and `false` otherwise.
+  */
+  ready(): boolean;
+  /**
+  * `block` returns immediately if the pollable is ready, and otherwise
+  * blocks until ready.
+  *
+  * This function is equivalent to calling `poll.poll` on a list
+  * containing only this pollable.
+  */
+  block(): void;
+    [Symbol.dispose]?: () => void;
+}

guests/typescript/generated/types/interfaces/wasi-io-streams.d.ts

@@ -0,0 +1,244 @@
+/** @module Interface wasi:io/streams@0.2.3 **/
+export type Error = import('./wasi-io-error.js').Error;
+export type Pollable = import('./wasi-io-poll.js').Pollable;
+/**
+ * An error for input-stream and output-stream operations.
+ */
+export type StreamError = StreamErrorLastOperationFailed | StreamErrorClosed;
+/**
+ * The last operation (a write or flush) failed before completion.
+ *
+ * More information is available in the `error` payload.
+ *
+ * After this, the stream will be closed. All future operations return
+ * `stream-error::closed`.
+ */
+export interface StreamErrorLastOperationFailed {
+  tag: 'last-operation-failed',
+  val: Error,
+}
+/**
+ * The stream is closed: no more input will be accepted by the
+ * stream. A closed output-stream will return this error on all
+ * future operations.
+ */
+export interface StreamErrorClosed {
+  tag: 'closed',
+}
+
+export class InputStream implements Partial<Disposable> {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
+  /**
+  * Perform a non-blocking read from the stream.
+  *
+  * When the source of a `read` is binary data, the bytes from the source
+  * are returned verbatim. When the source of a `read` is known to the
+  * implementation to be text, bytes containing the UTF-8 encoding of the
+  * text are returned.
+  *
+  * This function returns a list of bytes containing the read data,
+  * when successful. The returned list will contain up to `len` bytes;
+  * it may return fewer than requested, but not more. The list is
+  * empty when no bytes are available for reading at this time. The
+  * pollable given by `subscribe` will be ready when more bytes are
+  * available.
+  *
+  * This function fails with a `stream-error` when the operation
+  * encounters an error, giving `last-operation-failed`, or when the
+  * stream is closed, giving `closed`.
+  *
+  * When the caller gives a `len` of 0, it represents a request to
+  * read 0 bytes. If the stream is still open, this call should
+  * succeed and return an empty list, or otherwise fail with `closed`.
+  *
+  * The `len` parameter is a `u64`, which could represent a list of u8 which
+  * is not possible to allocate in wasm32, or not desirable to allocate as
+  * as a return value by the callee. The callee may return a list of bytes
+  * less than `len` in size while more bytes are available for reading.
+  */
+  read(len: bigint): Uint8Array;
+  /**
+  * Read bytes from a stream, after blocking until at least one byte can
+  * be read. Except for blocking, behavior is identical to `read`.
+  */
+  blockingRead(len: bigint): Uint8Array;
+  /**
+  * Skip bytes from a stream. Returns number of bytes skipped.
+  *
+  * Behaves identical to `read`, except instead of returning a list
+  * of bytes, returns the number of bytes consumed from the stream.
+  */
+  skip(len: bigint): bigint;
+  /**
+  * Skip bytes from a stream, after blocking until at least one byte
+  * can be skipped. Except for blocking behavior, identical to `skip`.
+  */
+  blockingSkip(len: bigint): bigint;
+  /**
+  * Create a `pollable` which will resolve once either the specified stream
+  * has bytes available to read or the other end of the stream has been
+  * closed.
+  * The created `pollable` is a child resource of the `input-stream`.
+  * Implementations may trap if the `input-stream` is dropped before
+  * all derived `pollable`s created with this function are dropped.
+  */
+  subscribe(): Pollable;
+    [Symbol.dispose]?: () => void;
+}
+
+export class OutputStream implements Partial<Disposable> {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
+  /**
+  * Check readiness for writing. This function never blocks.
+  *
+  * Returns the number of bytes permitted for the next call to `write`,
+  * or an error. Calling `write` with more bytes than this function has
+  * permitted will trap.
+  *
+  * When this function returns 0 bytes, the `subscribe` pollable will
+  * become ready when this function will report at least 1 byte, or an
+  * error.
+  */
+  checkWrite(): bigint;
+  /**
+  * Perform a write. This function never blocks.
+  *
+  * When the destination of a `write` is binary data, the bytes from
+  * `contents` are written verbatim. When the destination of a `write` is
+  * known to the implementation to be text, the bytes of `contents` are
+  * transcoded from UTF-8 into the encoding of the destination and then
+  * written.
+  *
+  * Precondition: check-write gave permit of Ok(n) and contents has a
+  * length of less than or equal to n. Otherwise, this function will trap.
+  *
+  * returns Err(closed) without writing if the stream has closed since
+  * the last call to check-write provided a permit.
+  */
+  write(contents: Uint8Array): void;
+  /**
+  * Perform a write of up to 4096 bytes, and then flush the stream. Block
+  * until all of these operations are complete, or an error occurs.
+  *
+  * This is a convenience wrapper around the use of `check-write`,
+  * `subscribe`, `write`, and `flush`, and is implemented with the
+  * following pseudo-code:
+  *
+  * ```text
+  * let pollable = this.subscribe();
+  * while !contents.is_empty() {
+    *     // Wait for the stream to become writable
+    *     pollable.block();
+    *     let Ok(n) = this.check-write(); // eliding error handling
+    *     let len = min(n, contents.len());
+    *     let (chunk, rest) = contents.split_at(len);
+    *     this.write(chunk  );            // eliding error handling
+    *     contents = rest;
+    * }
+    * this.flush();
+    * // Wait for completion of `flush`
+    * pollable.block();
+    * // Check for any errors that arose during `flush`
+    * let _ = this.check-write();         // eliding error handling
+    * ```
+    */
+    blockingWriteAndFlush(contents: Uint8Array): void;
+    /**
+    * Request to flush buffered output. This function never blocks.
+    *
+    * This tells the output-stream that the caller intends any buffered
+    * output to be flushed. the output which is expected to be flushed
+    * is all that has been passed to `write` prior to this call.
+    *
+    * Upon calling this function, the `output-stream` will not accept any
+    * writes (`check-write` will return `ok(0)`) until the flush has
+    * completed. The `subscribe` pollable will become ready when the
+    * flush has completed and the stream can accept more writes.
+    */
+    flush(): void;
+    /**
+    * Request to flush buffered output, and block until flush completes
+    * and stream is ready for writing again.
+    */
+    blockingFlush(): void;
+    /**
+    * Create a `pollable` which will resolve once the output-stream
+    * is ready for more writing, or an error has occurred. When this
+    * pollable is ready, `check-write` will return `ok(n)` with n>0, or an
+    * error.
+    *
+    * If the stream is closed, this pollable is always ready immediately.
+    *
+    * The created `pollable` is a child resource of the `output-stream`.
+    * Implementations may trap if the `output-stream` is dropped before
+    * all derived `pollable`s created with this function are dropped.
+    */
+    subscribe(): Pollable;
+    /**
+    * Write zeroes to a stream.
+    *
+    * This should be used precisely like `write` with the exact same
+    * preconditions (must use check-write first), but instead of
+    * passing a list of bytes, you simply pass the number of zero-bytes
+    * that should be written.
+    */
+    writeZeroes(len: bigint): void;
+    /**
+    * Perform a write of up to 4096 zeroes, and then flush the stream.
+    * Block until all of these operations are complete, or an error
+    * occurs.
+    *
+    * This is a convenience wrapper around the use of `check-write`,
+    * `subscribe`, `write-zeroes`, and `flush`, and is implemented with
+    * the following pseudo-code:
+    *
+    * ```text
+    * let pollable = this.subscribe();
+    * while num_zeroes != 0 {
+      *     // Wait for the stream to become writable
+      *     pollable.block();
+      *     let Ok(n) = this.check-write(); // eliding error handling
+      *     let len = min(n, num_zeroes);
+      *     this.write-zeroes(len);         // eliding error handling
+      *     num_zeroes -= len;
+      * }
+      * this.flush();
+      * // Wait for completion of `flush`
+      * pollable.block();
+      * // Check for any errors that arose during `flush`
+      * let _ = this.check-write();         // eliding error handling
+      * ```
+      */
+      blockingWriteZeroesAndFlush(len: bigint): void;
+      /**
+      * Read from one stream and write to another.
+      *
+      * The behavior of splice is equivalent to:
+      * 1. calling `check-write` on the `output-stream`
+      * 2. calling `read` on the `input-stream` with the smaller of the
+      * `check-write` permitted length and the `len` provided to `splice`
+      * 3. calling `write` on the `output-stream` with that read data.
+      *
+      * Any error reported by the call to `check-write`, `read`, or
+      * `write` ends the splice and reports that error.
+      *
+      * This function returns the number of bytes transferred; it may be less
+      * than `len`.
+      */
+      splice(src: InputStream, len: bigint): bigint;
+      /**
+      * Read from one stream and write to another, with blocking.
+      *
+      * This is similar to `splice`, except that it blocks until the
+      * `output-stream` is ready for writing, and the `input-stream`
+      * is ready for reading, before performing the `splice`.
+      */
+      blockingSplice(src: InputStream, len: bigint): bigint;
+        [Symbol.dispose]?: () => void;
+    }

guests/typescript/generated/types/interfaces/wasi-keyvalue-atomics.d.ts

@@ -0,0 +1,13 @@
+/** @module Interface wasi:keyvalue/atomics@0.2.0-draft **/
+/**
+ * Atomically increment the value associated with the key in the store by the given delta. It
+ * returns the new value.
+ *
+ * If the key does not exist in the store, it creates a new key-value pair with the value set
+ * to the given delta.
+ *
+ * If any other error occurs, it returns an `Err(error)`.
+ */
+export function increment(bucket: Bucket, key: string, delta: bigint): bigint;
+export type Bucket = import('./wasi-keyvalue-store.js').Bucket;
+export type Error = import('./wasi-keyvalue-store.js').Error;

guests/typescript/generated/types/interfaces/wasi-keyvalue-batch.d.ts

@@ -0,0 +1,47 @@
+/** @module Interface wasi:keyvalue/batch@0.2.0-draft **/
+/**
+ * Get the key-value pairs associated with the keys in the store. It returns a list of
+ * key-value pairs.
+ *
+ * If any of the keys do not exist in the store, it returns a `none` value for that pair in the
+ * list.
+ *
+ * MAY show an out-of-date value if there are concurrent writes to the store.
+ *
+ * If any other error occurs, it returns an `Err(error)`.
+ */
+export function getMany(bucket: Bucket, keys: Array<string>): Array<[string, Uint8Array] | undefined>;
+/**
+ * Set the values associated with the keys in the store. If the key already exists in the
+ * store, it overwrites the value.
+ *
+ * Note that the key-value pairs are not guaranteed to be set in the order they are provided.
+ *
+ * If any of the keys do not exist in the store, it creates a new key-value pair.
+ *
+ * If any other error occurs, it returns an `Err(error)`. When an error occurs, it does not
+ * rollback the key-value pairs that were already set. Thus, this batch operation does not
+ * guarantee atomicity, implying that some key-value pairs could be set while others might
+ * fail.
+ *
+ * Other concurrent operations may also be able to see the partial results.
+ */
+export function setMany(bucket: Bucket, keyValues: Array<[string, Uint8Array]>): void;
+/**
+ * Delete the key-value pairs associated with the keys in the store.
+ *
+ * Note that the key-value pairs are not guaranteed to be deleted in the order they are
+ * provided.
+ *
+ * If any of the keys do not exist in the store, it skips the key.
+ *
+ * If any other error occurs, it returns an `Err(error)`. When an error occurs, it does not
+ * rollback the key-value pairs that were already deleted. Thus, this batch operation does not
+ * guarantee atomicity, implying that some key-value pairs could be deleted while others might
+ * fail.
+ *
+ * Other concurrent operations may also be able to see the partial results.
+ */
+export function deleteMany(bucket: Bucket, keys: Array<string>): void;
+export type Bucket = import('./wasi-keyvalue-store.js').Bucket;
+export type Error = import('./wasi-keyvalue-store.js').Error;

guests/typescript/generated/types/interfaces/wasi-keyvalue-store.d.ts

@@ -0,0 +1,110 @@
+/** @module Interface wasi:keyvalue/store@0.2.0-draft **/
+/**
+ * Get the bucket with the specified identifier.
+ *
+ * `identifier` must refer to a bucket provided by the host.
+ *
+ * `error::no-such-store` will be raised if the `identifier` is not recognized.
+ */
+export function open(identifier: string): Bucket;
+/**
+ * The set of errors which may be raised by functions in this package
+ */
+export type Error = ErrorNoSuchStore | ErrorAccessDenied | ErrorOther;
+/**
+ * The host does not recognize the store identifier requested.
+ */
+export interface ErrorNoSuchStore {
+  tag: 'no-such-store',
+}
+/**
+ * The requesting component does not have access to the specified store
+ * (which may or may not exist).
+ */
+export interface ErrorAccessDenied {
+  tag: 'access-denied',
+}
+/**
+ * Some implementation-specific error has occurred (e.g. I/O)
+ */
+export interface ErrorOther {
+  tag: 'other',
+  val: string,
+}
+/**
+ * A response to a `list-keys` operation.
+ */
+export interface KeyResponse {
+  /**
+   * The list of keys returned by the query.
+   */
+  keys: Array<string>,
+  /**
+   * The continuation token to use to fetch the next page of keys. If this is `null`, then
+   * there are no more keys to fetch.
+   */
+  cursor?: bigint,
+}
+
+export class Bucket implements Partial<Disposable> {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
+  /**
+  * Get the value associated with the specified `key`
+  *
+  * The value is returned as an option. If the key-value pair exists in the
+  * store, it returns `Ok(value)`. If the key does not exist in the
+  * store, it returns `Ok(none)`.
+  *
+  * If any other error occurs, it returns an `Err(error)`.
+  */
+  get(key: string): Uint8Array | undefined;
+  /**
+  * Set the value associated with the key in the store. If the key already
+  * exists in the store, it overwrites the value.
+  *
+  * If the key does not exist in the store, it creates a new key-value pair.
+  *
+  * If any other error occurs, it returns an `Err(error)`.
+  */
+  set(key: string, value: Uint8Array): void;
+  /**
+  * Delete the key-value pair associated with the key in the store.
+  *
+  * If the key does not exist in the store, it does nothing.
+  *
+  * If any other error occurs, it returns an `Err(error)`.
+  */
+  'delete'(key: string): void;
+  /**
+  * Check if the key exists in the store.
+  *
+  * If the key exists in the store, it returns `Ok(true)`. If the key does
+  * not exist in the store, it returns `Ok(false)`.
+  *
+  * If any other error occurs, it returns an `Err(error)`.
+  */
+  exists(key: string): boolean;
+  /**
+  * Get all the keys in the store with an optional cursor (for use in pagination). It
+  * returns a list of keys. Please note that for most KeyValue implementations, this is a
+  * can be a very expensive operation and so it should be used judiciously. Implementations
+  * can return any number of keys in a single response, but they should never attempt to
+  * send more data than is reasonable (i.e. on a small edge device, this may only be a few
+  * KB, while on a large machine this could be several MB). Any response should also return
+  * a cursor that can be used to fetch the next page of keys. See the `key-response` record
+  * for more information.
+  *
+  * Note that the keys are not guaranteed to be returned in any particular order.
+  *
+  * If the store is empty, it returns an empty list.
+  *
+  * MAY show an out-of-date list of keys if there are concurrent writes to the store.
+  *
+  * If any error occurs, it returns an `Err(error)`.
+  */
+  listKeys(cursor: bigint | undefined): KeyResponse;
+    [Symbol.dispose]?: () => void;
+}

guests/typescript/generated/types/interfaces/wasi-random-insecure-seed.d.ts

@@ -0,0 +1,21 @@
+/** @module Interface wasi:random/insecure-seed@0.2.3 **/
+/**
+ * Return a 128-bit value that may contain a pseudo-random value.
+ *
+ * The returned value is not required to be computed from a CSPRNG, and may
+ * even be entirely deterministic. Host implementations are encouraged to
+ * provide pseudo-random values to any program exposed to
+ * attacker-controlled content, to enable DoS protection built into many
+ * languages' hash-map implementations.
+ *
+ * This function is intended to only be called once, by a source language
+ * to initialize Denial Of Service (DoS) protection in its hash-map
+ * implementation.
+ *
+ * # Expected future evolution
+ *
+ * This will likely be changed to a value import, to prevent it from being
+ * called multiple times and potentially used for purposes other than DoS
+ * protection.
+ */
+export function insecureSeed(): [bigint, bigint];

guests/typescript/generated/types/interfaces/wasi-random-insecure.d.ts

@@ -0,0 +1,19 @@
+/** @module Interface wasi:random/insecure@0.2.3 **/
+/**
+ * Return `len` insecure pseudo-random bytes.
+ *
+ * This function is not cryptographically secure. Do not use it for
+ * anything related to security.
+ *
+ * There are no requirements on the values of the returned bytes, however
+ * implementations are encouraged to return evenly distributed values with
+ * a long period.
+ */
+export function getInsecureRandomBytes(len: bigint): Uint8Array;
+/**
+ * Return an insecure pseudo-random `u64` value.
+ *
+ * This function returns the same type of pseudo-random data as
+ * `get-insecure-random-bytes`, represented as a `u64`.
+ */
+export function getInsecureRandomU64(): bigint;

guests/typescript/generated/types/interfaces/wasi-random-random.d.ts

@@ -0,0 +1,23 @@
+/** @module Interface wasi:random/random@0.2.3 **/
+/**
+ * Return `len` cryptographically-secure random or pseudo-random bytes.
+ *
+ * This function must produce data at least as cryptographically secure and
+ * fast as an adequately seeded cryptographically-secure pseudo-random
+ * number generator (CSPRNG). It must not block, from the perspective of
+ * the calling program, under any circumstances, including on the first
+ * request and on requests for numbers of bytes. The returned data must
+ * always be unpredictable.
+ *
+ * This function must always return fresh data. Deterministic environments
+ * must omit this function, rather than implementing it with deterministic
+ * data.
+ */
+export function getRandomBytes(len: bigint): Uint8Array;
+/**
+ * Return a cryptographically-secure random or pseudo-random `u64` value.
+ *
+ * This function returns the same type of data as `get-random-bytes`,
+ * represented as a `u64`.
+ */
+export function getRandomU64(): bigint;

guests/typescript/generated/types/wit.d.ts

@@ -0,0 +1,19 @@
+// world trailbase:runtime/trailbase
+export type * as TrailbaseRuntimeHostEndpoint from './interfaces/trailbase-runtime-host-endpoint.js'; // import trailbase:runtime/host-endpoint
+export type * as WasiClocksMonotonicClock023 from './interfaces/wasi-clocks-monotonic-clock.js'; // import wasi:clocks/monotonic-clock@0.2.3
+export type * as WasiClocksWallClock023 from './interfaces/wasi-clocks-wall-clock.js'; // import wasi:clocks/wall-clock@0.2.3
+export type * as WasiFilesystemPreopens023 from './interfaces/wasi-filesystem-preopens.js'; // import wasi:filesystem/preopens@0.2.3
+export type * as WasiFilesystemTypes023 from './interfaces/wasi-filesystem-types.js'; // import wasi:filesystem/types@0.2.3
+export type * as WasiHttpOutgoingHandler023 from './interfaces/wasi-http-outgoing-handler.js'; // import wasi:http/outgoing-handler@0.2.3
+export type * as WasiHttpTypes023 from './interfaces/wasi-http-types.js'; // import wasi:http/types@0.2.3
+export type * as WasiIoError023 from './interfaces/wasi-io-error.js'; // import wasi:io/error@0.2.3
+export type * as WasiIoPoll023 from './interfaces/wasi-io-poll.js'; // import wasi:io/poll@0.2.3
+export type * as WasiIoStreams023 from './interfaces/wasi-io-streams.js'; // import wasi:io/streams@0.2.3
+export type * as WasiKeyvalueAtomics020Draft from './interfaces/wasi-keyvalue-atomics.js'; // import wasi:keyvalue/atomics@0.2.0-draft
+export type * as WasiKeyvalueBatch020Draft from './interfaces/wasi-keyvalue-batch.js'; // import wasi:keyvalue/batch@0.2.0-draft
+export type * as WasiKeyvalueStore020Draft from './interfaces/wasi-keyvalue-store.js'; // import wasi:keyvalue/store@0.2.0-draft
+export type * as WasiRandomInsecureSeed023 from './interfaces/wasi-random-insecure-seed.js'; // import wasi:random/insecure-seed@0.2.3
+export type * as WasiRandomInsecure023 from './interfaces/wasi-random-insecure.js'; // import wasi:random/insecure@0.2.3
+export type * as WasiRandomRandom023 from './interfaces/wasi-random-random.js'; // import wasi:random/random@0.2.3
+export * as initEndpoint from './interfaces/trailbase-runtime-init-endpoint.js'; // export trailbase:runtime/init-endpoint
+export * as incomingHandler from './interfaces/wasi-http-incoming-handler.js'; // export wasi:http/incoming-handler@0.2.3

guests/typescript/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "trailbase-wasm",
+  "description": "WASM Runtime for JS/TS execution within TrailBase",
+  "version": "0.1.0",
+  "license": "OSL-3.0",
+  "type": "module",
+  "homepage": "https://trailbase.io",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./db": "./dist/db.js",
+    "./fs": "./dist/fs.js",
+    "./http": "./dist/http.js",
+    "./job": "./dist/job.js",
+    "./kv": "./dist/kv.js"
+  },
+  "scripts": {
+    "generate:types": "jco types wit/ -o generated/types",
+    "build": "npm run generate:types && vite build",
+    "check": "tsc --noEmit --skipLibCheck && vite build && eslint",
+    "format": "prettier -w src tests",
+    "test": "vitest run"
+  },
+  "devDependencies": {
+    "@bytecodealliance/componentize-js": "^0.18.4",
+    "@bytecodealliance/jco": "=1.13.3",
+    "@eslint/js": "^9.33.0",
+    "eslint": "^9.33.0",
+    "prettier": "^3.6.2",
+    "typescript": "^5.9.2",
+    "typescript-eslint": "^8.39.1",
+    "vite": "^7.1.2",
+    "vite-plugin-dts": "^4.5.4",
+    "vitest": "^3.2.4"
+  },
+  "dependencies": {}
+}

guests/typescript/src/db/index.ts

@@ -0,0 +1,104 @@
+import {
+  txBegin,
+  txCommit,
+  txRollback,
+  txExecute,
+  txQuery,
+} from "trailbase:runtime/host-endpoint";
+
+import type { SqliteRequest } from "@common/SqliteRequest";
+import type { Value } from "./value";
+
+import { JsonValue } from "@common/serde_json/JsonValue";
+import { fromJsonValue, toJsonValue, toWitValue, fromWitValue } from "./value";
+
+export type { Value } from "trailbase:runtime/host-endpoint";
+
+// export class DbError extends Error {
+//   readonly error: TxError;
+//
+//   constructor(error: TxError) {
+//     super(`${error}`);
+//     this.error = error;
+//   }
+//
+//   public override toString(): string {
+//     return `DbError(${this.error})`;
+//   }
+// }
+
+export class Transaction {
+  constructor() {
+    txBegin();
+  }
+
+  query(query: string, params: Value[]): Value[][] {
+    return txQuery(query, params.map(toWitValue)).map((row) =>
+      row.map(fromWitValue),
+    );
+  }
+
+  execute(query: string, params: Value[]): number {
+    return Number(txExecute(query, params.map(toWitValue)));
+  }
+
+  commit(): void {
+    txCommit();
+  }
+  rollback(): void {
+    txRollback();
+  }
+}
+
+export async function query(
+  query: string,
+  params: Value[],
+): Promise<Value[][]> {
+  const body: SqliteRequest = {
+    query,
+    params: params.map(toJsonValue),
+  };
+  const reply = await fetch("http://__sqlite/query", {
+    method: "POST",
+    headers: [["content-type", "application/json"]],
+    body: JSON.stringify(body),
+  });
+
+  const json = await reply.json();
+  if ("Error" in json) {
+    const response = json as { Error: string };
+    throw new Error(response.Error);
+  }
+
+  try {
+    const response = json as { Query: { rows: Array<Array<JsonValue>> } };
+    return response.Query.rows.map((row) => row.map(fromJsonValue));
+  } catch (e) {
+    throw new Error(`Unexpected response '${JSON.stringify(json)}': ${e}`);
+  }
+}
+
+export async function execute(query: string, params: Value[]): Promise<number> {
+  const body: SqliteRequest = {
+    query,
+    params: params.map(toJsonValue),
+  };
+  const reply = await fetch("http://__sqlite/execute", {
+    method: "POST",
+    headers: [["content-type", "application/json"]],
+    body: JSON.stringify(body),
+  });
+
+  const json = await reply.json();
+  if ("Error" in json) {
+    const response = json as { Error: string };
+    throw new Error(response.Error);
+  }
+
+  try {
+    const response = json as { Execute: { rows_affected: number } };
+    return response.Execute.rows_affected;
+  } catch (e) {
+    throw new Error(`Unexpected response '${JSON.stringify(json)}': ${e}`);
+  }
+}

guests/typescript/src/db/value.ts

@@ -0,0 +1,79 @@
+import type { Value as WitValue } from "trailbase:runtime/host-endpoint";
+import { JsonValue } from "@common/serde_json/JsonValue";
+
+import { urlSafeBase64Encode, urlSafeBase64Decode } from "../util";
+
+export type Blob = { blob: string };
+export type Value = number | string | boolean | Uint8Array | Blob | null;
+
+export function toJsonValue(value: Value): JsonValue {
+  if (value === null) {
+    return null;
+  } else if (typeof value === "number") {
+    return value;
+  } else if (typeof value === "string") {
+    return value;
+  } else if (typeof value === "boolean") {
+    return value ? 1 : 0;
+  } else if (value instanceof Uint8Array) {
+    return { blob: urlSafeBase64Encode(value) };
+  } else if ("blob" in value) {
+    return value;
+  }
+
+  throw new Error(`Invalid value: ${value}`);
+}
+
+export function fromJsonValue(value: JsonValue): Value {
+  if (value === null) {
+    return value;
+  } else if (typeof value === "number") {
+    return value;
+  } else if (typeof value === "string") {
+    return value;
+  } else if (typeof value === "boolean") {
+    return value ? 1 : 0;
+  } else if ("blob" in value) {
+    return urlSafeBase64Decode((value as Blob).blob);
+  } else if (value == null) {
+    return null;
+  }
+
+  throw new Error(`Invalid value: ${value}`);
+}
+
+export function toWitValue(val: Value): WitValue {
+  if (val === null) {
+    return { tag: "null" };
+  } else if (typeof val === "number") {
+    if (Number.isInteger(val)) {
+      return { tag: "integer", val: BigInt(val) };
+    }
+    return { tag: "real", val };
+  } else if (typeof val === "string") {
+    return { tag: "text", val };
+  } else if (typeof val === "boolean") {
+    return { tag: "integer", val: val ? BigInt(1) : BigInt(0) };
+  } else if (val instanceof Uint8Array) {
+    return { tag: "blob", val };
+  } else if ("blob" in val) {
+    return { tag: "blob", val: urlSafeBase64Decode(val.blob) };
+  }
+
+  throw new Error(`Invalid value: ${val}`);
+}
+
+export function fromWitValue(val: WitValue): Value {
+  switch (val.tag) {
+    case "null":
+      return null;
+    case "integer":
+      return Number(val.val);
+    case "real":
+      return val.val;
+    case "text":
+      return val.val;
+    case "blob":
+      return val.val;
+  }
+}

guests/typescript/src/fs/index.ts

@@ -0,0 +1,57 @@
+import {
+  getDirectories,
+  type Descriptor,
+} from "wasi:filesystem/preopens@0.2.3";
+import type { PathFlags } from "wasi:filesystem/types@0.2.3";
+
+// Override setInterval/setTimeout.
+import "../timer";
+
+export function readFileSync(path: string): Uint8Array {
+  const root = getDirectories().find(([_, path]) => path === "/")?.[0];
+  if (!root) {
+    throw new Error("Missing '/'");
+  }
+
+  const segments = path.split("/");
+  let descriptor: Descriptor = root;
+
+  for (const [i, segment] of segments.entries()) {
+    if (i === 0) {
+      if (segment !== "") {
+        throw new Error(`Only absolute paths, got: ${path}`);
+      }
+      continue;
+    }
+
+    const last = i == segments.length - 1;
+    const flags: PathFlags = {
+      symlinkFollow: false,
+    };
+
+    descriptor = descriptor.openAt(
+      flags,
+      segment,
+      last ? {} : { directory: true },
+      { read: true },
+    );
+
+    if (last) {
+      const MAX = BigInt(1024 * 1024);
+      const buffer = [];
+
+      while (true) {
+        const [bytes, eof] = descriptor.read(MAX, BigInt(buffer.length));
+        buffer.push(...bytes);
+
+        if (eof) {
+          break;
+        }
+      }
+
+      return Uint8Array.from(buffer);
+    }
+  }
+
+  throw new Error("not found");
+}

guests/typescript/src/http/incoming.ts

@@ -0,0 +1,117 @@
+import {
+  IncomingRequest,
+  OutgoingResponse,
+  ResponseOutparam,
+  Method as WasiMethod,
+} from "wasi:http/types@0.2.3";
+
+import type { HttpContext } from "@common/HttpContext";
+import type { HttpHandlerInterface, ResponseType } from "./index";
+import { HttpError, StatusCode, buildResponse } from "./index";
+import { type Method, RequestImpl } from "./request";
+import { JobHandlerInterface } from "../job";
+import { awaitPendingTimers } from "../timer";
+
+type IncomingHandler = (
+  req: IncomingRequest,
+  respOutparam: ResponseOutparam,
+) => Promise<void>;
+
+export function encodeBytes(body: string): Uint8Array {
+  return new TextEncoder().encode(body);
+}
+
+export function buildIncomingHttpHandler(args: {
+  httpHandlers?: HttpHandlerInterface[];
+  jobHandlers?: JobHandlerInterface[];
+}): IncomingHandler {
+  const httpHandlers = Object.fromEntries(
+    (args.httpHandlers ?? []).map((h) => [h.path, h.handler]),
+  );
+  const jobHandlers = Object.fromEntries(
+    (args.jobHandlers ?? []).map((h) => [h.name, h.handler]),
+  );
+
+  async function handle(req: IncomingRequest): Promise<ResponseType> {
+    const path: string | undefined = req.pathWithQuery();
+    if (!path) {
+      throw new HttpError(StatusCode.NOT_FOUND, "path not found");
+    }
+
+    const context: HttpContext = JSON.parse(
+      new TextDecoder().decode(req.headers().get("__context")[0]),
+    );
+
+    if (context.kind === "Job") {
+      const handler = jobHandlers[context.registered_path];
+      await handler();
+      return new Uint8Array();
+    } else {
+      const handler = httpHandlers[context.registered_path];
+      if (!handler) {
+        throw new HttpError(StatusCode.NOT_FOUND, "impl not found");
+      }
+
+      return await handler(
+        new RequestImpl(
+          wasiMethodToMethod(req.method()),
+          req.pathWithQuery() ?? "",
+          context.path_params,
+          req.scheme(),
+          req.authority() ?? "",
+          req.headers(),
+          context.user,
+          req.consume(),
+        ),
+      );
+    }
+  }
+
+  return async function (req: IncomingRequest, respOutparam: ResponseOutparam) {
+    try {
+      const resp: ResponseType = await handle(req);
+      writeResponse(
+        respOutparam,
+        resp instanceof OutgoingResponse
+          ? resp
+          : buildResponse(
+              resp instanceof Uint8Array ? resp : encodeBytes(resp ?? ""),
+            ),
+      );
+    } catch (err) {
+      if (err instanceof HttpError) {
+        writeResponse(
+          respOutparam,
+          buildResponse(encodeBytes(`${err.message}\n`), {
+            status: err.statusCode,
+          }),
+        );
+      } else {
+        writeResponse(
+          respOutparam,
+          buildResponse(encodeBytes(`Other: ${err}\n`), {
+            status: StatusCode.INTERNAL_SERVER_ERROR,
+          }),
+        );
+      }
+    } finally {
+      await awaitPendingTimers();
+    }
+  };
+}
+
+function writeResponse(
+  responseOutparam: ResponseOutparam,
+  response: OutgoingResponse,
+) {
+  ResponseOutparam.set(responseOutparam, { tag: "ok", val: response });
+}
+
+function wasiMethodToMethod(method: WasiMethod): Method {
+  switch (method.tag) {
+    case "other":
+      throw new HttpError(StatusCode.INTERNAL_SERVER_ERROR, "other method");
+    default:
+      return method.tag;
+  }
+}

guests/typescript/src/http/index.ts

@@ -0,0 +1,215 @@
+import { Fields, OutgoingBody, OutgoingResponse } from "wasi:http/types@0.2.3";
+import type { MethodType } from "trailbase:runtime/init-endpoint";
+
+import { StatusCode } from "./status";
+import { Request } from "./request";
+import { encodeBytes } from "./incoming";
+
+// Override setInterval/setTimeout.
+import "../timer";
+
+export { OutgoingResponse } from "wasi:http/types@0.2.3";
+export { StatusCode } from "./status";
+export type { Request, Scheme, User } from "./request";
+
+export type ResponseType = string | Uint8Array | OutgoingResponse | void;
+export type HttpHandlerCallback = (
+  req: Request,
+) => ResponseType | Promise<ResponseType>;
+
+export interface HttpHandlerInterface {
+  path: string;
+  method: MethodType;
+  handler: HttpHandlerCallback;
+}
+
+export class HttpHandler implements HttpHandlerInterface {
+  constructor(
+    public readonly path: string,
+    public readonly method: MethodType,
+    public readonly handler: HttpHandlerCallback,
+  ) {}
+
+  static get(path: string, handler: HttpHandlerCallback): HttpHandler {
+    return new HttpHandler(path, "get", handler);
+  }
+
+  static post(path: string, handler: HttpHandlerCallback): HttpHandler {
+    return new HttpHandler(path, "post", handler);
+  }
+
+  static head(path: string, handler: HttpHandlerCallback): HttpHandler {
+    return new HttpHandler(path, "head", handler);
+  }
+
+  static options(path: string, handler: HttpHandlerCallback): HttpHandler {
+    return new HttpHandler(path, "options", handler);
+  }
+
+  static patch(path: string, handler: HttpHandlerCallback): HttpHandler {
+    return new HttpHandler(path, "patch", handler);
+  }
+
+  static delete(path: string, handler: HttpHandlerCallback): HttpHandler {
+    return new HttpHandler(path, "delete", handler);
+  }
+
+  static put(path: string, handler: HttpHandlerCallback): HttpHandler {
+    return new HttpHandler(path, "put", handler);
+  }
+}
+
+export class HttpError extends Error {
+  readonly statusCode: number;
+  readonly headers: [string, string][] | undefined;
+
+  constructor(
+    statusCode: number,
+    message?: string,
+    headers?: [string, string][],
+  ) {
+    super(message);
+    this.statusCode = statusCode;
+    this.headers = headers;
+  }
+
+  public override toString(): string {
+    return `HttpError(${this.statusCode}, ${this.message})`;
+  }
+}
+
+export type ResponseOptions = {
+  status?: StatusCode;
+  headers?: [string, Uint8Array][];
+};
+
+export function buildJsonResponse(
+  body: object,
+  opts?: ResponseOptions,
+): OutgoingResponse {
+  return buildResponse(encodeBytes(JSON.stringify(body)), {
+    ...opts,
+
+    headers: [
+      ["Content-Type", encodeBytes("application/json")],
+      ...(opts?.headers ?? []),
+    ],
+  });
+}
+
+export function buildResponse(
+  body: Uint8Array,
+  opts?: ResponseOptions,
+): OutgoingResponse {
+  // NOTE: `outputStream.blockingWriteAndFlush` only writes up to 4kB, see documentation.
+  if (body.length <= 4096) {
+    return buildSmallResponse(body, opts);
+  }
+  return buildLargeResponse(body, opts);
+}
+
+function buildSmallResponse(
+  body: Uint8Array,
+  opts?: ResponseOptions,
+): OutgoingResponse {
+  const outgoingResponse = new OutgoingResponse(
+    Fields.fromList(opts?.headers ?? []),
+  );
+
+  const outgoingBody = outgoingResponse.body();
+  {
+    // Create a stream for the response body
+    const outputStream = outgoingBody.write();
+    outputStream.blockingWriteAndFlush(body);
+
+    outputStream[Symbol.dispose]?.();
+  }
+
+  outgoingResponse.setStatusCode(opts?.status ?? StatusCode.OK);
+
+  OutgoingBody.finish(outgoingBody, undefined);
+
+  return outgoingResponse;
+}
+
+function buildLargeResponse(
+  body: Uint8Array,
+  opts?: ResponseOptions,
+): OutgoingResponse {
+  const outgoingResponse = new OutgoingResponse(
+    Fields.fromList(opts?.headers ?? []),
+  );
+
+  const outgoingBody = outgoingResponse.body();
+  {
+    const outputStream = outgoingBody.write();
+
+    // Retrieve a Preview 2 I/O pollable to coordinate writing to the output stream
+    const pollable = outputStream.subscribe();
+
+    let written = 0n;
+    let remaining = BigInt(body.length);
+    while (remaining > 0) {
+      // Wait for the stream to become writable
+      pollable.block();
+
+      // Get the amount of bytes that we're allowed to write
+      let writableByteCount = outputStream.checkWrite();
+      if (remaining <= writableByteCount) {
+        writableByteCount = BigInt(remaining);
+      }
+
+      // If we are not allowed to write any more, but there are still bytes
+      // remaining then flush and try again
+      if (writableByteCount === 0n && remaining !== 0n) {
+        outputStream.flush();
+        continue;
+      }
+
+      outputStream.write(
+        new Uint8Array(body.buffer, Number(written), Number(writableByteCount)),
+      );
+      written += writableByteCount;
+      remaining -= written;
+
+      // While we can track *when* to flush separately and implement our own logic,
+      // the simplest way is to flush the written chunk immediately
+      outputStream.flush();
+    }
+
+    pollable[Symbol.dispose]?.();
+    outputStream[Symbol.dispose]?.();
+  }
+
+  outgoingResponse.setStatusCode(opts?.status ?? StatusCode.OK);
+
+  OutgoingBody.finish(outgoingBody, undefined);
+
+  return outgoingResponse;
+}
+
+// function writeResponseOriginal(
+//   responseOutparam: ResponseOutparam,
+//   status: number,
+//   body: Uint8Array,
+// ) {
+//   /* eslint-disable prefer-const */
+//   const outgoingResponse = new OutgoingResponse(new Fields());
+//
+//   let outgoingBody = outgoingResponse.body();
+//   {
+//     // Create a stream for the response body
+//     let outputStream = outgoingBody.write();
+//     outputStream.blockingWriteAndFlush(body);
+//
+//     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+//     // @ts-ignore: This is required in order to dispose the stream before we return
+//     outputStream[Symbol.dispose]();
+//     //outputStream[Symbol.dispose]?.();
+//   }
+//
+//   outgoingResponse.setStatusCode(status);
+//   OutgoingBody.finish(outgoingBody, undefined);
+//
+//   ResponseOutparam.set(responseOutparam, { tag: "ok", val: outgoingResponse });
+// }

guests/typescript/src/http/request.ts

@@ -0,0 +1,136 @@
+import {
+  Headers,
+  IncomingBody,
+  Scheme as WasiScheme,
+} from "wasi:http/types@0.2.3";
+import type { MethodType } from "trailbase:runtime/init-endpoint";
+import type { HttpContextUser } from "@common/HttpContextUser";
+
+export type Scheme = "HTTP" | "HTTPS" | "other";
+export type Method = MethodType;
+
+export type User = {
+  id: string;
+  email: string;
+  csrf: string;
+};
+
+export interface Request {
+  path(): string;
+  method(): Method;
+  scheme(): Scheme | undefined;
+  authority(): string;
+  headers(): [string, Uint8Array][];
+  url(): URL;
+  getQueryParam(param: string): string | null;
+
+  // Path parameter, e.g. `/test/{param}/v0/`.
+  pathParams(): [string, string][];
+  getPathParam(param: string): string | null;
+
+  // User metadata.
+  user(): User | null;
+
+  // Body accessors:
+  body(): Uint8Array | undefined;
+  json(): object | undefined;
+}
+
+export class RequestImpl implements Request {
+  constructor(
+    private readonly _method: Method,
+    private readonly _path: string,
+    private readonly _params: [string, string][],
+    private readonly _scheme: WasiScheme | undefined,
+    private readonly _authority: string,
+    private readonly _headers: Headers,
+    private readonly _user: HttpContextUser | null,
+    private readonly _body: IncomingBody,
+  ) {}
+
+  path(): string {
+    return this._path;
+  }
+
+  method(): Method {
+    return this._method;
+  }
+
+  scheme(): Scheme | undefined {
+    return this._scheme?.tag;
+  }
+
+  authority(): string {
+    return this._authority;
+  }
+
+  headers(): [string, Uint8Array][] {
+    return this._headers.entries();
+  }
+
+  user(): User | null {
+    const u = this._user;
+    return u === null
+      ? null
+      : {
+          id: u.id,
+          email: u.email,
+          csrf: u.csrf_token,
+        };
+  }
+
+  url(): URL {
+    const base =
+      this._scheme !== undefined
+        ? `${printScheme(this._scheme)}://${this._authority}/${this._path}`
+        : `/${this._path}`;
+    return new URL(base);
+  }
+
+  getQueryParam(param: string): string | null {
+    return this.url().searchParams.get(param);
+  }
+
+  pathParams(): [string, string][] {
+    return this._params;
+  }
+
+  getPathParam(param: string): string | null {
+    for (const [p, v] of this._params) {
+      if (p === param) return v;
+    }
+    return null;
+  }
+
+  body(): Uint8Array | undefined {
+    switch (this._method) {
+      case "get":
+      case "head":
+        // NOTE: Throws stream closed for GET and HEAD requests.
+        return undefined;
+      default: {
+        const s = this._body.stream();
+        return s.read(BigInt(Number.MAX_SAFE_INTEGER));
+      }
+    }
+  }
+
+  json(): object | undefined {
+    const b = this.body();
+    if (b !== undefined) {
+      return JSON.parse(new TextDecoder().decode(b));
+    }
+    return undefined;
+  }
+}
+
+function printScheme(scheme: WasiScheme): string {
+  switch (scheme.tag) {
+    case "HTTP":
+      return "http";
+    case "HTTPS":
+      return "https";
+    case "other":
+      return scheme.val;
+  }
+}

guests/typescript/src/http/status.ts

@@ -0,0 +1,347 @@
+/// HTTP status codes.
+///
+// source: https://github.com/prettymuchbryce/http-status-codes/blob/master/src/status-codes.ts
+export enum StatusCode {
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.2.1
+  ///
+  /// This interim response indicates that everything so far is OK and that the
+  /// client should continue with the request or ignore it if it is already
+  /// finished.
+  CONTINUE = 100,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.2.2
+  ///
+  /// This code is sent in response to an Upgrade request header by the client,
+  /// and indicates the protocol the server is switching too.
+  SWITCHING_PROTOCOLS = 101,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc2518#section-10.1
+  ///
+  /// This code indicates that the server has received and is processing the
+  /// request, but no response is available yet.
+  PROCESSING = 102,
+  /// Official Documentation @ https://www.rfc-editor.org/rfc/rfc8297#page-3
+  ///
+  /// This code indicates to the client that the server is likely to send a
+  /// final response with the header fields included in the informational
+  /// response.
+  EARLY_HINTS = 103,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.3.1
+  ///
+  /// The request has succeeded. The meaning of a success varies depending on the HTTP method:
+  /// GET: The resource has been fetched and is transmitted in the message body.
+  /// HEAD: The entity headers are in the message body.
+  /// POST: The resource describing the result of the action is transmitted in the message body.
+  /// TRACE: The message body contains the request message as received by the server
+  OK = 200,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.3.2
+  ///
+  /// The request has succeeded and a new resource has been created as a result
+  /// of it. This is typically the response sent after a PUT request.
+  CREATED = 201,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.3.3
+  ///
+  /// The request has been received but not yet acted upon. It is
+  /// non-committal, meaning that there is no way in HTTP to later send an
+  /// asynchronous response indicating the outcome of processing the request. It
+  /// is intended for cases where another process or server handles the request,
+  /// or for batch processing.
+  ACCEPTED = 202,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.3.4
+  ///
+  /// This response code means returned meta-information set is not exact set
+  /// as available from the origin server, but collected from a local or a third
+  /// party copy. Except this condition, 200 OK response should be preferred
+  /// instead of this response.
+  NON_AUTHORITATIVE_INFORMATION = 203,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.3.5
+  ///
+  /// There is no content to send for this request, but the headers may be
+  /// useful. The user-agent may update its cached headers for this resource with
+  /// the new ones.
+  NO_CONTENT = 204,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.3.6
+  ///
+  /// This response code is sent after accomplishing request to tell user agent
+  /// reset document view which sent this request.
+  RESET_CONTENT = 205,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7233#section-4.1
+  ///
+  /// This response code is used because of range header sent by the client to
+  /// separate download into multiple streams.
+  PARTIAL_CONTENT = 206,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc2518#section-10.2
+  ///
+  /// A Multi-Status response conveys information about multiple resources in
+  /// situations where multiple status codes might be appropriate.
+  MULTI_STATUS = 207,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.4.1
+  ///
+  /// The request has more than one possible responses. User-agent or user
+  /// should choose one of them. There is no standardized way to choose one of
+  /// the responses.
+  MULTIPLE_CHOICES = 300,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.4.2
+  ///
+  /// This response code means that URI of requested resource has been changed.
+  /// Probably, new URI would be given in the response.
+  MOVED_PERMANENTLY = 301,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.4.3
+  ///
+  /// This response code means that URI of requested resource has been changed
+  /// temporarily. New changes in the URI might be made in the future. Therefore,
+  /// this same URI should be used by the client in future requests.
+  MOVED_TEMPORARILY = 302,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.4.4
+  ///
+  /// Server sent this response to directing client to get requested resource
+  /// to another URI with an GET request.
+  SEE_OTHER = 303,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7232#section-4.1
+  ///
+  /// This is used for caching purposes. It is telling to client that response
+  /// has not been modified. So, client can continue to use same cached version
+  /// of response.
+  NOT_MODIFIED = 304,
+  /// @deprecated
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.4.6
+  ///
+  /// Was defined in a previous version of the HTTP specification to indicate
+  /// that a requested response must be accessed by a proxy. It has been
+  /// deprecated due to security concerns regarding in-band configuration of a
+  /// proxy.
+  USE_PROXY = 305,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.4.7
+  ///
+  /// Server sent this response to directing client to get requested resource
+  /// to another URI with same method that used prior request. This has the same
+  /// semantic than the 302 Found HTTP response code, with the exception that the
+  /// user agent must not change the HTTP method used: if a POST was used in the
+  /// first request, a POST must be used in the second request.
+  TEMPORARY_REDIRECT = 307,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7538#section-3
+  ///
+  /// This means that the resource is now permanently located at another URI,
+  /// specified by the Location: HTTP Response header. This has the same
+  /// semantics as the 301 Moved Permanently HTTP response code, with the
+  /// exception that the user agent must not change the HTTP method used: if a
+  /// POST was used in the first request, a POST must be used in the second
+  /// request.
+  PERMANENT_REDIRECT = 308,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.1
+  ///
+  /// This response means that server could not understand the request due to invalid syntax.
+  BAD_REQUEST = 400,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7235#section-3.1
+  ///
+  /// Although the HTTP standard specifies "unauthorized", semantically this
+  /// response means "unauthenticated". That is, the client must authenticate
+  /// itself to get the requested response.
+  UNAUTHORIZED = 401,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.2
+  ///
+  /// This response code is reserved for future use. Initial aim for creating
+  /// this code was using it for digital payment systems however this is not used
+  /// currently.
+  PAYMENT_REQUIRED = 402,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.3
+  ///
+  /// The client does not have access rights to the content, i.e. they are
+  /// unauthorized, so server is rejecting to give proper response. Unlike 401,
+  /// the client's identity is known to the server.
+  FORBIDDEN = 403,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.4
+  ///
+  /// The server can not find requested resource. In the browser, this means
+  /// the URL is not recognized. In an API, this can also mean that the endpoint
+  /// is valid but the resource itself does not exist. Servers may also send this
+  /// response instead of 403 to hide the existence of a resource from an
+  /// unauthorized client. This response code is probably the most famous one due
+  /// to its frequent occurence on the web.
+  NOT_FOUND = 404,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.5
+  ///
+  /// The request method is known by the server but has been disabled and
+  /// cannot be used. For example, an API may forbid DELETE-ing a resource. The
+  /// two mandatory methods, GET and HEAD, must never be disabled and should not
+  /// return this error code.
+  METHOD_NOT_ALLOWED = 405,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.6
+  ///
+  /// This response is sent when the web server, after performing server-driven
+  /// content negotiation, doesn't find any content following the criteria given
+  /// by the user agent.
+  NOT_ACCEPTABLE = 406,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7235#section-3.2
+  ///
+  /// This is similar to 401 but authentication is needed to be done by a proxy.
+  PROXY_AUTHENTICATION_REQUIRED = 407,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.7
+  ///
+  /// This response is sent on an idle connection by some servers, even without
+  /// any previous request by the client. It means that the server would like to
+  /// shut down this unused connection. This response is used much more since
+  /// some browsers, like Chrome, Firefox 27+, or IE9, use HTTP pre-connection
+  /// mechanisms to speed up surfing. Also note that some servers merely shut
+  /// down the connection without sending this message.
+  REQUEST_TIMEOUT = 408,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.8
+  ///
+  /// This response is sent when a request conflicts with the current state of the server.
+  CONFLICT = 409,
+  ///
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.9
+  ///
+  /// This response would be sent when the requested content has been
+  /// permenantly deleted from server, with no forwarding address. Clients are
+  /// expected to remove their caches and links to the resource. The HTTP
+  /// specification intends this status code to be used for "limited-time,
+  /// promotional services". APIs should not feel compelled to indicate resources
+  /// that have been deleted with this status code.
+  GONE = 410,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.10
+  ///
+  /// The server rejected the request because the Content-Length header field
+  /// is not defined and the server requires it.
+  LENGTH_REQUIRED = 411,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7232#section-4.2
+  ///
+  /// The client has indicated preconditions in its headers which the server
+  /// does not meet.
+  PRECONDITION_FAILED = 412,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.11
+  ///
+  /// Request entity is larger than limits defined by server; the server might
+  /// close the connection or return an Retry-After header field.
+  REQUEST_TOO_LONG = 413,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.12
+  ///
+  /// The URI requested by the client is longer than the server is willing to interpret.
+  REQUEST_URI_TOO_LONG = 414,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.13
+  ///
+  /// The media format of the requested data is not supported by the server, so
+  /// the server is rejecting the request.
+  UNSUPPORTED_MEDIA_TYPE = 415,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7233#section-4.4
+  ///
+  /// The range specified by the Range header field in the request can't be
+  /// fulfilled; it's possible that the range is outside the size of the target
+  /// URI's data.
+  REQUESTED_RANGE_NOT_SATISFIABLE = 416,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.14
+  ///
+  /// This response code means the expectation indicated by the Expect request
+  /// header field can't be met by the server.
+  EXPECTATION_FAILED = 417,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc2324#section-2.3.2
+  ///
+  /// Any attempt to brew coffee with a teapot should result in the error code
+  /// "418 I'm a teapot". The resulting entity body MAY be short and stout.
+  IM_A_TEAPOT = 418,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc2518#section-10.6
+  ///
+  /// The 507 (Insufficient Storage) status code means the method could not be
+  /// performed on the resource because the server is unable to store the
+  /// representation needed to successfully complete the request. This condition
+  /// is considered to be temporary. If the request which received this status
+  /// code was the result of a user action, the request MUST NOT be repeated
+  /// until it is requested by a separate user action.
+  INSUFFICIENT_SPACE_ON_RESOURCE = 419,
+  /// @deprecated
+  /// Official Documentation @ https://tools.ietf.org/rfcdiff?difftype=--hwdiff&url2=draft-ietf-webdav-protocol-06.txt
+  ///
+  /// A deprecated response used by the Spring Framework when a method has failed.
+  METHOD_FAILURE = 420,
+  /// Official Documentation @ https://datatracker.ietf.org/doc/html/rfc7540#section-9.1.2
+  ///
+  /// Defined in the specification of HTTP/2 to indicate that a server is not
+  /// able to produce a response for the combination of scheme and authority that
+  /// are included in the request URI.
+  MISDIRECTED_REQUEST = 421,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc2518#section-10.3
+  ///
+  /// The request was well-formed but was unable to be followed due to semantic errors.
+  UNPROCESSABLE_ENTITY = 422,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc2518#section-10.4
+  ///
+  /// The resource that is being accessed is locked.
+  LOCKED = 423,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc2518#section-10.5
+  ///
+  /// The request failed due to failure of a previous request.
+  FAILED_DEPENDENCY = 424,
+  /// Official Documentation @ https://datatracker.ietf.org/doc/html/rfc7231#section-6.5.15
+  ///
+  /// The server refuses to perform the request using the current protocol but
+  /// might be willing to do so after the client upgrades to a different
+  /// protocol.
+  UPGRADE_REQUIRED = 426,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc6585#section-3
+  ///
+  /// The origin server requires the request to be conditional. Intended to
+  /// prevent the 'lost update' problem, where a client GETs a resource's state,
+  /// modifies it, and PUTs it back to the server, when meanwhile a third party
+  /// has modified the state on the server, leading to a conflict.
+  PRECONDITION_REQUIRED = 428,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc6585#section-4
+  ///
+  /// The user has sent too many requests in a given amount of time ("rate limiting").
+  TOO_MANY_REQUESTS = 429,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc6585#section-5
+  ///
+  /// The server is unwilling to process the request because its header fields
+  /// are too large. The request MAY be resubmitted after reducing the size of
+  /// the request header fields.
+  REQUEST_HEADER_FIELDS_TOO_LARGE = 431,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7725
+  ///
+  /// The user-agent requested a resource that cannot legally be provided, such
+  /// as a web page censored by a government.
+  UNAVAILABLE_FOR_LEGAL_REASONS = 451,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.6.1
+  ///
+  /// The server encountered an unexpected condition that prevented it from
+  /// fulfilling the request.
+  INTERNAL_SERVER_ERROR = 500,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.6.2
+  ///
+  /// The request method is not supported by the server and cannot be handled.
+  /// The only methods that servers are required to support (and therefore that
+  /// must not return this code) are GET and HEAD.
+  NOT_IMPLEMENTED = 501,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.6.3
+  ///
+  /// This error response means that the server, while working as a gateway to
+  /// get a response needed to handle the request, got an invalid response.
+  BAD_GATEWAY = 502,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.6.4
+  ///
+  /// The server is not ready to handle the request. Common causes are a server
+  /// that is down for maintenance or that is overloaded. Note that together with
+  /// this response, a user-friendly page explaining the problem should be sent.
+  /// This responses should be used for temporary conditions and the Retry-After:
+  /// HTTP header should, if possible, contain the estimated time before the
+  /// recovery of the service. The webmaster must also take care about the
+  /// caching-related headers that are sent along with this response, as these
+  /// temporary condition responses should usually not be cached.
+  SERVICE_UNAVAILABLE = 503,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.6.5
+  ///
+  /// This error response is given when the server is acting as a gateway and
+  /// cannot get a response in time.
+  GATEWAY_TIMEOUT = 504,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.6.6
+  ///
+  /// The HTTP version used in the request is not supported by the server.
+  HTTP_VERSION_NOT_SUPPORTED = 505,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc2518#section-10.6
+  ///
+  /// The server has an internal configuration error: the chosen variant
+  /// resource is configured to engage in transparent content negotiation itself,
+  /// and is therefore not a proper end point in the negotiation process.
+  INSUFFICIENT_STORAGE = 507,
+  /// Official Documentation @ https://tools.ietf.org/html/rfc6585#section-6
+  ///
+  /// The 511 status code indicates that the client needs to authenticate to
+  /// gain network access.
+  NETWORK_AUTHENTICATION_REQUIRED = 511,
+}

guests/typescript/src/index.ts

@@ -0,0 +1,45 @@
+import { IncomingRequest, ResponseOutparam } from "wasi:http/types@0.2.3";
+import type { InitResult } from "trailbase:runtime/init-endpoint";
+import type { HttpHandlerInterface } from "./http";
+import type { JobHandlerInterface } from "./job";
+import { buildIncomingHttpHandler } from "./http/incoming";
+
+export { addPeriodicCallback } from "./timer";
+
+export * from "./util";
+export type { InitResult } from "trailbase:runtime/init-endpoint";
+export { threadId } from "trailbase:runtime/host-endpoint";
+
+export interface Config {
+  incomingHandler: {
+    handle: (
+      req: IncomingRequest,
+      respOutparam: ResponseOutparam,
+    ) => Promise<void>;
+  };
+  initEndpoint: {
+    init: () => InitResult;
+  };
+}
+
+export function defineConfig(args: {
+  httpHandlers?: HttpHandlerInterface[];
+  jobHandlers?: JobHandlerInterface[];
+}): Config {
+  return {
+    incomingHandler: {
+      handle: buildIncomingHttpHandler(args),
+    },
+    initEndpoint: {
+      init: function (): InitResult {
+        return {
+          httpHandlers: (args.httpHandlers ?? []).map((h) => [
+            h.method,
+            h.path,
+          ]),
+          jobHandlers: (args.jobHandlers ?? []).map((h) => [h.name, h.spec]),
+        };
+      },
+    },
+  };
+}

guests/typescript/src/job/index.ts

@@ -0,0 +1,47 @@
+export type JobHandlerType = () => void | Promise<void>;
+
+export type JobHandlerInterface = {
+  name: string;
+  spec: string;
+  handler: JobHandlerType;
+};
+
+export class JobHandler implements JobHandlerInterface {
+  constructor(
+    public readonly name: string,
+    public readonly spec: string,
+    public readonly handler: JobHandlerType,
+  ) {
+    validateSpec(this.spec);
+  }
+
+  static hourly(name: string, handler: JobHandlerType): JobHandler {
+    return new JobHandler(name, "@hourly", handler);
+  }
+
+  static minutely(name: string, handler: JobHandlerType): JobHandler {
+    const second: number = 5;
+    return new JobHandler(name, `${second} * * * * *`, handler);
+  }
+}
+
+function validateSpec(spec: string) {
+  switch (spec) {
+    case "@hourly":
+    case "@daily":
+    case "@weekly":
+    case "@monthly":
+    case "@yearly":
+      return;
+    default: {
+      const components = spec.trim().split(" ");
+      switch (components.length) {
+        case 6:
+        case 7:
+          return;
+        default:
+          throw new Error(`Unepxected number of components: ${spec}`);
+      }
+    }
+  }
+}

guests/typescript/src/kv/index.ts

@@ -0,0 +1,32 @@
+import { Bucket, open as witOpen } from "wasi:keyvalue/store@0.2.0-draft";
+
+// Override setInterval/setTimeout.
+import "../timer";
+
+export function open(): Store {
+  return new Store(witOpen(""));
+}
+
+export class Store {
+  constructor(private readonly bucket: Bucket) {}
+
+  static open(): Store {
+    return new Store(witOpen(""));
+  }
+
+  get(key: string): Uint8Array | undefined {
+    return this.bucket.get(key);
+  }
+
+  set(key: string, value: Uint8Array) {
+    this.bucket.set(key, value);
+  }
+
+  delete(key: string) {
+    this.bucket.delete(key);
+  }
+
+  exists(key: string): boolean {
+    return this.bucket.exists(key);
+  }
+}

guests/typescript/src/timer.ts

@@ -0,0 +1,90 @@
+const intrinsicSetInterval = globalThis.setInterval;
+const intrinsicClearInterval = globalThis.clearInterval;
+
+const intrinsicSetTimeout = globalThis.setTimeout;
+const intrinsicClearTimeout = globalThis.clearTimeout;
+
+type Timeout = number;
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+type TimerHandler = Function | string;
+
+const PENDING_INTERVALS: Map<Timeout, PromiseWithResolvers<void>> = new Map();
+const PENDING_TIMEOUTS: Map<Timeout, PromiseWithResolvers<void>> = new Map();
+
+export async function awaitPendingTimers() {
+  await Promise.all([...PENDING_INTERVALS.values()].map((p) => p.promise));
+  await Promise.all([...PENDING_TIMEOUTS.values()].map((p) => p.promise));
+}
+
+function setTimeout<TArgs>(
+  handler: TimerHandler,
+  ms?: number,
+  ...args: TArgs[]
+): Timeout {
+  if (typeof handler === "string") {
+    // Avoid a dependency on `eval`.
+    throw new Error("string handlers not supported");
+  }
+
+  const promiseWithResolvers = Promise.withResolvers<void>();
+
+  const handle: Timeout = intrinsicSetTimeout(() => {
+    handler(...args);
+    promiseWithResolvers.resolve();
+  }, ms);
+
+  PENDING_TIMEOUTS.set(handle, promiseWithResolvers);
+
+  return handle;
+}
+
+globalThis.setTimeout = setTimeout;
+
+function clearTimeout(id: number | undefined): void {
+  if (id !== undefined) {
+    PENDING_TIMEOUTS.get(id)?.resolve();
+    PENDING_TIMEOUTS.delete(id);
+  }
+  intrinsicClearTimeout(id);
+}
+
+globalThis.clearTimeout = clearTimeout;
+
+function setInterval<TArgs>(
+  handler: TimerHandler,
+  ms?: number,
+  ...args: TArgs[]
+): Timeout {
+  if (typeof handler === "string") {
+    // Avoid a dependency on `eval`.
+    throw new Error("string handlers not supported");
+  }
+
+  const handle: Timeout = intrinsicSetInterval(handler, ms, ...args);
+  PENDING_INTERVALS.set(handle, Promise.withResolvers());
+  return handle;
+}
+
+globalThis.setInterval = setInterval;
+
+function clearInterval(id: number | undefined): void {
+  if (id !== undefined) {
+    PENDING_INTERVALS.get(id)?.resolve();
+    PENDING_INTERVALS.delete(id);
+  }
+  intrinsicClearInterval(id);
+}
+
+globalThis.clearInterval = clearInterval;
+
+/// Install a periodic callback (compatible from JS runtime).
+export function addPeriodicCallback(
+  ms: number,
+  cb: (cancel: () => void) => void,
+): () => void {
+  const handle = setInterval(() => {
+    cb(() => clearInterval(handle));
+  }, ms);
+
+  return () => clearInterval(handle);
+}

guests/typescript/src/util.ts

@@ -0,0 +1,19 @@
+/// Decode a base64 string to bytes.
+export function base64Decode(base64: string): Uint8Array {
+  return Uint8Array.from(atob(base64), (c) => c.charCodeAt(0));
+}
+
+/// Decode a "url-safe" base64 string to bytes.
+export function urlSafeBase64Decode(base64: string): Uint8Array {
+  return base64Decode(base64.replace(/_/g, "/").replace(/-/g, "+"));
+}
+
+/// Encode an arbitrary string input as base64 string.
+export function base64Encode(b: Uint8Array): string {
+  return btoa(String.fromCharCode(...b));
+}
+
+/// Encode an arbitrary string input as a "url-safe" base64 string.
+export function urlSafeBase64Encode(b: Uint8Array): string {
+  return base64Encode(b).replace(/\//g, "_").replace(/\+/g, "-");
+}

guests/typescript/tests/runtime.test.ts

@@ -0,0 +1,54 @@
+import { test, expect } from "vitest";
+import {
+  fromJsonValue,
+  toJsonValue,
+  fromWitValue,
+  toWitValue,
+} from "../src/db/value";
+import { urlSafeBase64Encode, urlSafeBase64Decode } from "../src/util";
+
+test("base64", () => {
+  expect(
+    urlSafeBase64Decode(urlSafeBase64Encode(Uint8Array.from([0]))),
+  ).toEqual(Uint8Array.from([0]));
+  expect(urlSafeBase64Decode(urlSafeBase64Encode(Uint8Array.from([])))).toEqual(
+    Uint8Array.from([]),
+  );
+  expect(
+    urlSafeBase64Decode(urlSafeBase64Encode(Uint8Array.from([1, 0]))),
+  ).toEqual(Uint8Array.from([1, 0]));
+});
+
+test("JSON value conversion", () => {
+  expect(fromJsonValue(toJsonValue(true))).toEqual(1);
+  expect(fromJsonValue(toJsonValue(false))).toEqual(0);
+  expect(fromJsonValue(toJsonValue(5))).toEqual(5);
+  expect(fromJsonValue(toJsonValue(-5))).toEqual(-5);
+  expect(fromJsonValue(toJsonValue(5.123))).toEqual(5.123);
+  expect(fromJsonValue(toJsonValue(-5.123))).toEqual(-5.123);
+  expect(fromJsonValue(toJsonValue(""))).toEqual("");
+  expect(fromJsonValue(toJsonValue(Uint8Array.from([])))).toEqual(
+    Uint8Array.from([]),
+  );
+  expect(fromJsonValue(toJsonValue(Uint8Array.from([0, 0])))).toEqual(
+    Uint8Array.from([0, 0]),
+  );
+  expect(fromJsonValue(toJsonValue(null))).toEqual(null);
+});
+
+test("Wit value conversion", () => {
+  expect(fromWitValue(toWitValue(true))).toEqual(1);
+  expect(fromWitValue(toWitValue(false))).toEqual(0);
+  expect(fromWitValue(toWitValue(5))).toEqual(5);
+  expect(fromWitValue(toWitValue(-5))).toEqual(-5);
+  expect(fromWitValue(toWitValue(5.123))).toEqual(5.123);
+  expect(fromWitValue(toWitValue(-5.123))).toEqual(-5.123);
+  expect(fromWitValue(toWitValue(""))).toEqual("");
+  expect(fromWitValue(toWitValue(Uint8Array.from([])))).toEqual(
+    Uint8Array.from([]),
+  );
+  expect(fromWitValue(toWitValue(Uint8Array.from([0, 0])))).toEqual(
+    Uint8Array.from([0, 0]),
+  );
+  expect(fromWitValue(toWitValue(null))).toEqual(null);
+});

guests/typescript/tsconfig.json

@@ -0,0 +1,41 @@
+{
+  "compilerOptions": {
+    "target": "es2024",
+    "module": "esnext",
+    "lib": ["es2024", "DOM", "esnext.disposable"],
+    "moduleResolution": "bundler",
+    "declaration": true,
+    "strict": true,
+    "strictNullChecks": true,
+    "forceConsistentCasingInFileNames": true,
+    "esModuleInterop": false,
+    "outDir": "./dist/",
+    "paths": {
+      "@common/*": ["./generated/common/*"],
+
+      "wasi:http/types@0.2.3": [
+        "./generated/types/interfaces/wasi-http-types.d.ts"
+      ],
+      "wasi:random/random@0.2.3": [
+        "./generated/types/interfaces/wasi-random-random.d.ts"
+      ],
+      "wasi:filesystem/preopens@0.2.3": [
+        "./generated/types/interfaces/wasi-filesystem-preopens.d.ts"
+      ],
+      "wasi:filesystem/types@0.2.3": [
+        "./generated/types/interfaces/wasi-filesystem-types.d.ts"
+      ],
+      "wasi:keyvalue/store@0.2.0-draft": [
+        "./generated/types/interfaces/wasi-keyvalue-store.d.ts",
+      ],
+      "trailbase:runtime/init-endpoint": [
+        "./generated/types/interfaces/trailbase-runtime-init-endpoint.d.ts"
+      ],
+      "trailbase:runtime/host-endpoint": [
+        "./generated/types/interfaces/trailbase-runtime-host-endpoint.d.ts"
+      ]
+    }
+  },
+  "include": ["./src/**/*", "./generated/**/*"],
+  "exclude": ["node_modules/", "tests/"]
+}

guests/typescript/vite.config.ts

@@ -0,0 +1,45 @@
+import { resolve } from "path";
+import { defineConfig } from "vite";
+import dts from "vite-plugin-dts";
+
+const entryPoints = {
+  "index": resolve(__dirname, 'src/index.ts'),
+  "db": resolve(__dirname, 'src/db/index.ts'),
+  "fs": resolve(__dirname, 'src/fs/index.ts'),
+  "http": resolve(__dirname, 'src/http/index.ts'),
+  "job": resolve(__dirname, 'src/job/index.ts'),
+  "kv": resolve(__dirname, 'src/kv/index.ts'),
+};
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function external(source: string, _importer: string | undefined, _isResolved: boolean): boolean {
+  return source.startsWith("wasi:") || source.startsWith("trailbase:");
+}
+
+export default defineConfig({
+  build: {
+    outDir: "./dist",
+    minify: false,
+    lib: {
+      entry: Object.values(entryPoints),
+      formats: ["es"],
+    },
+    rollupOptions: {
+      plugins: [
+        // NOTE: Needs to be in `rollupOptions` rather than vite's plugins to apply to each input.
+        dts({
+          rollupTypes: true,
+          // NOTE: Inlucde .d.ts files generated by `jco`.
+          copyDtsFiles: true,
+          // NOTE: The .d.ts files generated by `jco` contain dynamic imports.
+          staticImport: true,
+        }),
+      ],
+      input: entryPoints,
+      output: {
+        entryFileNames: "[name].js",
+      },
+      external,
+    },
+  },
+});

guests/typescript/wit/deps/cli/command.wit

@@ -0,0 +1,10 @@
+package wasi:cli@0.2.3;
+
+@since(version = 0.2.0)
+world command {
+  @since(version = 0.2.0)
+  include imports;
+
+  @since(version = 0.2.0)
+  export run;
+}

guests/typescript/wit/deps/cli/environment.wit

@@ -0,0 +1,22 @@
+@since(version = 0.2.0)
+interface environment {
+  /// Get the POSIX-style environment variables.
+  ///
+  /// Each environment variable is provided as a pair of string variable names
+  /// and string value.
+  ///
+  /// Morally, these are a value import, but until value imports are available
+  /// in the component model, this import function should return the same
+  /// values each time it is called.
+  @since(version = 0.2.0)
+  get-environment: func() -> list<tuple<string, string>>;
+
+  /// Get the POSIX-style arguments to the program.
+  @since(version = 0.2.0)
+  get-arguments: func() -> list<string>;
+
+  /// Return a path that programs should use as their initial current working
+  /// directory, interpreting `.` as shorthand for this.
+  @since(version = 0.2.0)
+  initial-cwd: func() -> option<string>;
+}

guests/typescript/wit/deps/cli/exit.wit

@@ -0,0 +1,17 @@
+@since(version = 0.2.0)
+interface exit {
+  /// Exit the current instance and any linked instances.
+  @since(version = 0.2.0)
+  exit: func(status: result);
+
+  /// Exit the current instance and any linked instances, reporting the
+  /// specified status code to the host.
+  ///
+  /// The meaning of the code depends on the context, with 0 usually meaning
+  /// "success", and other values indicating various types of failure.
+  ///
+  /// This function does not return; the effect is analogous to a trap, but
+  /// without the connotation that something bad has happened.
+  @unstable(feature = cli-exit-with-code)
+  exit-with-code: func(status-code: u8);
+}

guests/typescript/wit/deps/cli/imports.wit

@@ -0,0 +1,36 @@
+package wasi:cli@0.2.3;
+
+@since(version = 0.2.0)
+world imports {
+  @since(version = 0.2.0)
+  include wasi:clocks/imports@0.2.3;
+  @since(version = 0.2.0)
+  include wasi:filesystem/imports@0.2.3;
+  @since(version = 0.2.0)
+  include wasi:sockets/imports@0.2.3;
+  @since(version = 0.2.0)
+  include wasi:random/imports@0.2.3;
+  @since(version = 0.2.0)
+  include wasi:io/imports@0.2.3;
+
+  @since(version = 0.2.0)
+  import environment;
+  @since(version = 0.2.0)
+  import exit;
+  @since(version = 0.2.0)
+  import stdin;
+  @since(version = 0.2.0)
+  import stdout;
+  @since(version = 0.2.0)
+  import stderr;
+  @since(version = 0.2.0)
+  import terminal-input;
+  @since(version = 0.2.0)
+  import terminal-output;
+  @since(version = 0.2.0)
+  import terminal-stdin;
+  @since(version = 0.2.0)
+  import terminal-stdout;
+  @since(version = 0.2.0)
+  import terminal-stderr;
+}

guests/typescript/wit/deps/cli/run.wit

@@ -0,0 +1,6 @@
+@since(version = 0.2.0)
+interface run {
+  /// Run the program.
+  @since(version = 0.2.0)
+  run: func() -> result;
+}

guests/typescript/wit/deps/cli/stdio.wit

@@ -0,0 +1,26 @@
+@since(version = 0.2.0)
+interface stdin {
+  @since(version = 0.2.0)
+  use wasi:io/streams@0.2.3.{input-stream};
+
+  @since(version = 0.2.0)
+  get-stdin: func() -> input-stream;
+}
+
+@since(version = 0.2.0)
+interface stdout {
+  @since(version = 0.2.0)
+  use wasi:io/streams@0.2.3.{output-stream};
+
+  @since(version = 0.2.0)
+  get-stdout: func() -> output-stream;
+}
+
+@since(version = 0.2.0)
+interface stderr {
+  @since(version = 0.2.0)
+  use wasi:io/streams@0.2.3.{output-stream};
+
+  @since(version = 0.2.0)
+  get-stderr: func() -> output-stream;
+}

guests/typescript/wit/deps/cli/terminal.wit

@@ -0,0 +1,62 @@
+/// Terminal input.
+///
+/// In the future, this may include functions for disabling echoing,
+/// disabling input buffering so that keyboard events are sent through
+/// immediately, querying supported features, and so on.
+@since(version = 0.2.0)
+interface terminal-input {
+    /// The input side of a terminal.
+    @since(version = 0.2.0)
+    resource terminal-input;
+}
+
+/// Terminal output.
+///
+/// In the future, this may include functions for querying the terminal
+/// size, being notified of terminal size changes, querying supported
+/// features, and so on.
+@since(version = 0.2.0)
+interface terminal-output {
+    /// The output side of a terminal.
+    @since(version = 0.2.0)
+    resource terminal-output;
+}
+
+/// An interface providing an optional `terminal-input` for stdin as a
+/// link-time authority.
+@since(version = 0.2.0)
+interface terminal-stdin {
+    @since(version = 0.2.0)
+    use terminal-input.{terminal-input};
+
+    /// If stdin is connected to a terminal, return a `terminal-input` handle
+    /// allowing further interaction with it.
+    @since(version = 0.2.0)
+    get-terminal-stdin: func() -> option<terminal-input>;
+}
+
+/// An interface providing an optional `terminal-output` for stdout as a
+/// link-time authority.
+@since(version = 0.2.0)
+interface terminal-stdout {
+    @since(version = 0.2.0)
+    use terminal-output.{terminal-output};
+
+    /// If stdout is connected to a terminal, return a `terminal-output` handle
+    /// allowing further interaction with it.
+    @since(version = 0.2.0)
+    get-terminal-stdout: func() -> option<terminal-output>;
+}
+
+/// An interface providing an optional `terminal-output` for stderr as a
+/// link-time authority.
+@since(version = 0.2.0)
+interface terminal-stderr {
+    @since(version = 0.2.0)
+    use terminal-output.{terminal-output};
+
+    /// If stderr is connected to a terminal, return a `terminal-output` handle
+    /// allowing further interaction with it.
+    @since(version = 0.2.0)
+    get-terminal-stderr: func() -> option<terminal-output>;
+}

guests/typescript/wit/deps/clocks/monotonic-clock.wit

@@ -0,0 +1,50 @@
+package wasi:clocks@0.2.3;
+/// WASI Monotonic Clock is a clock API intended to let users measure elapsed
+/// time.
+///
+/// It is intended to be portable at least between Unix-family platforms and
+/// Windows.
+///
+/// A monotonic clock is a clock which has an unspecified initial value, and
+/// successive reads of the clock will produce non-decreasing values.
+@since(version = 0.2.0)
+interface monotonic-clock {
+    @since(version = 0.2.0)
+    use wasi:io/poll@0.2.3.{pollable};
+
+    /// An instant in time, in nanoseconds. An instant is relative to an
+    /// unspecified initial value, and can only be compared to instances from
+    /// the same monotonic-clock.
+    @since(version = 0.2.0)
+    type instant = u64;
+
+    /// A duration of time, in nanoseconds.
+    @since(version = 0.2.0)
+    type duration = u64;
+
+    /// Read the current value of the clock.
+    ///
+    /// The clock is monotonic, therefore calling this function repeatedly will
+    /// produce a sequence of non-decreasing values.
+    @since(version = 0.2.0)
+    now: func() -> instant;
+
+    /// Query the resolution of the clock. Returns the duration of time
+    /// corresponding to a clock tick.
+    @since(version = 0.2.0)
+    resolution: func() -> duration;
+
+    /// Create a `pollable` which will resolve once the specified instant
+    /// has occurred.
+    @since(version = 0.2.0)
+    subscribe-instant: func(
+        when: instant,
+    ) -> pollable;
+
+    /// Create a `pollable` that will resolve after the specified duration has
+    /// elapsed from the time this function is invoked.
+    @since(version = 0.2.0)
+    subscribe-duration: func(
+        when: duration,
+    ) -> pollable;
+}

guests/typescript/wit/deps/clocks/timezone.wit

@@ -0,0 +1,55 @@
+package wasi:clocks@0.2.3;
+
+@unstable(feature = clocks-timezone)
+interface timezone {
+    @unstable(feature = clocks-timezone)
+    use wall-clock.{datetime};
+
+    /// Return information needed to display the given `datetime`. This includes
+    /// the UTC offset, the time zone name, and a flag indicating whether
+    /// daylight saving time is active.
+    ///
+    /// If the timezone cannot be determined for the given `datetime`, return a
+    /// `timezone-display` for `UTC` with a `utc-offset` of 0 and no daylight
+    /// saving time.
+    @unstable(feature = clocks-timezone)
+    display: func(when: datetime) -> timezone-display;
+
+    /// The same as `display`, but only return the UTC offset.
+    @unstable(feature = clocks-timezone)
+    utc-offset: func(when: datetime) -> s32;
+
+    /// Information useful for displaying the timezone of a specific `datetime`.
+    ///
+    /// This information may vary within a single `timezone` to reflect daylight
+    /// saving time adjustments.
+    @unstable(feature = clocks-timezone)
+    record timezone-display {
+        /// The number of seconds difference between UTC time and the local
+        /// time of the timezone.
+        ///
+        /// The returned value will always be less than 86400 which is the
+        /// number of seconds in a day (24*60*60).
+        ///
+        /// In implementations that do not expose an actual time zone, this
+        /// should return 0.
+        utc-offset: s32,
+
+        /// The abbreviated name of the timezone to display to a user. The name
+        /// `UTC` indicates Coordinated Universal Time. Otherwise, this should
+        /// reference local standards for the name of the time zone.
+        ///
+        /// In implementations that do not expose an actual time zone, this
+        /// should be the string `UTC`.
+        ///
+        /// In time zones that do not have an applicable name, a formatted
+        /// representation of the UTC offset may be returned, such as `-04:00`.
+        name: string,
+
+        /// Whether daylight saving time is active.
+        ///
+        /// In implementations that do not expose an actual time zone, this
+        /// should return false.
+        in-daylight-saving-time: bool,
+    }
+}

guests/typescript/wit/deps/clocks/wall-clock.wit

@@ -0,0 +1,46 @@
+package wasi:clocks@0.2.3;
+/// WASI Wall Clock is a clock API intended to let users query the current
+/// time. The name "wall" makes an analogy to a "clock on the wall", which
+/// is not necessarily monotonic as it may be reset.
+///
+/// It is intended to be portable at least between Unix-family platforms and
+/// Windows.
+///
+/// A wall clock is a clock which measures the date and time according to
+/// some external reference.
+///
+/// External references may be reset, so this clock is not necessarily
+/// monotonic, making it unsuitable for measuring elapsed time.
+///
+/// It is intended for reporting the current date and time for humans.
+@since(version = 0.2.0)
+interface wall-clock {
+    /// A time and date in seconds plus nanoseconds.
+    @since(version = 0.2.0)
+    record datetime {
+        seconds: u64,
+        nanoseconds: u32,
+    }
+
+    /// Read the current value of the clock.
+    ///
+    /// This clock is not monotonic, therefore calling this function repeatedly
+    /// will not necessarily produce a sequence of non-decreasing values.
+    ///
+    /// The returned timestamps represent the number of seconds since
+    /// 1970-01-01T00:00:00Z, also known as [POSIX's Seconds Since the Epoch],
+    /// also known as [Unix Time].
+    ///
+    /// The nanoseconds field of the output is always less than 1000000000.
+    ///
+    /// [POSIX's Seconds Since the Epoch]: https://pubs.opengroup.org/onlinepubs/9699919799/xrat/V4_xbd_chap04.html#tag_21_04_16
+    /// [Unix Time]: https://en.wikipedia.org/wiki/Unix_time
+    @since(version = 0.2.0)
+    now: func() -> datetime;
+
+    /// Query the resolution of the clock.
+    ///
+    /// The nanoseconds field of the output is always less than 1000000000.
+    @since(version = 0.2.0)
+    resolution: func() -> datetime;
+}

guests/typescript/wit/deps/clocks/world.wit

@@ -0,0 +1,11 @@
+package wasi:clocks@0.2.3;
+
+@since(version = 0.2.0)
+world imports {
+    @since(version = 0.2.0)
+    import monotonic-clock;
+    @since(version = 0.2.0)
+    import wall-clock;
+    @unstable(feature = clocks-timezone)
+    import timezone;
+}

guests/typescript/wit/deps/filesystem/preopens.wit

@@ -0,0 +1,11 @@
+package wasi:filesystem@0.2.3;
+
+@since(version = 0.2.0)
+interface preopens {
+    @since(version = 0.2.0)
+    use types.{descriptor};
+
+    /// Return the set of preopened directories, and their paths.
+    @since(version = 0.2.0)
+    get-directories: func() -> list<tuple<descriptor, string>>;
+}

guests/typescript/wit/deps/filesystem/types.wit

@@ -0,0 +1,672 @@
+package wasi:filesystem@0.2.3;
+/// WASI filesystem is a filesystem API primarily intended to let users run WASI
+/// programs that access their files on their existing filesystems, without
+/// significant overhead.
+///
+/// It is intended to be roughly portable between Unix-family platforms and
+/// Windows, though it does not hide many of the major differences.
+///
+/// Paths are passed as interface-type `string`s, meaning they must consist of
+/// a sequence of Unicode Scalar Values (USVs). Some filesystems may contain
+/// paths which are not accessible by this API.
+///
+/// The directory separator in WASI is always the forward-slash (`/`).
+///
+/// All paths in WASI are relative paths, and are interpreted relative to a
+/// `descriptor` referring to a base directory. If a `path` argument to any WASI
+/// function starts with `/`, or if any step of resolving a `path`, including
+/// `..` and symbolic link steps, reaches a directory outside of the base
+/// directory, or reaches a symlink to an absolute or rooted path in the
+/// underlying filesystem, the function fails with `error-code::not-permitted`.
+///
+/// For more information about WASI path resolution and sandboxing, see
+/// [WASI filesystem path resolution].
+///
+/// [WASI filesystem path resolution]: https://github.com/WebAssembly/wasi-filesystem/blob/main/path-resolution.md
+@since(version = 0.2.0)
+interface types {
+    @since(version = 0.2.0)
+    use wasi:io/streams@0.2.3.{input-stream, output-stream, error};
+    @since(version = 0.2.0)
+    use wasi:clocks/wall-clock@0.2.3.{datetime};
+
+    /// File size or length of a region within a file.
+    @since(version = 0.2.0)
+    type filesize = u64;
+
+    /// The type of a filesystem object referenced by a descriptor.
+    ///
+    /// Note: This was called `filetype` in earlier versions of WASI.
+    @since(version = 0.2.0)
+    enum descriptor-type {
+        /// The type of the descriptor or file is unknown or is different from
+        /// any of the other types specified.
+        unknown,
+        /// The descriptor refers to a block device inode.
+        block-device,
+        /// The descriptor refers to a character device inode.
+        character-device,
+        /// The descriptor refers to a directory inode.
+        directory,
+        /// The descriptor refers to a named pipe.
+        fifo,
+        /// The file refers to a symbolic link inode.
+        symbolic-link,
+        /// The descriptor refers to a regular file inode.
+        regular-file,
+        /// The descriptor refers to a socket.
+        socket,
+    }
+
+    /// Descriptor flags.
+    ///
+    /// Note: This was called `fdflags` in earlier versions of WASI.
+    @since(version = 0.2.0)
+    flags descriptor-flags {
+        /// Read mode: Data can be read.
+        read,
+        /// Write mode: Data can be written to.
+        write,
+        /// Request that writes be performed according to synchronized I/O file
+        /// integrity completion. The data stored in the file and the file's
+        /// metadata are synchronized. This is similar to `O_SYNC` in POSIX.
+        ///
+        /// The precise semantics of this operation have not yet been defined for
+        /// WASI. At this time, it should be interpreted as a request, and not a
+        /// requirement.
+        file-integrity-sync,
+        /// Request that writes be performed according to synchronized I/O data
+        /// integrity completion. Only the data stored in the file is
+        /// synchronized. This is similar to `O_DSYNC` in POSIX.
+        ///
+        /// The precise semantics of this operation have not yet been defined for
+        /// WASI. At this time, it should be interpreted as a request, and not a
+        /// requirement.
+        data-integrity-sync,
+        /// Requests that reads be performed at the same level of integrity
+        /// requested for writes. This is similar to `O_RSYNC` in POSIX.
+        ///
+        /// The precise semantics of this operation have not yet been defined for
+        /// WASI. At this time, it should be interpreted as a request, and not a
+        /// requirement.
+        requested-write-sync,
+        /// Mutating directories mode: Directory contents may be mutated.
+        ///
+        /// When this flag is unset on a descriptor, operations using the
+        /// descriptor which would create, rename, delete, modify the data or
+        /// metadata of filesystem objects, or obtain another handle which
+        /// would permit any of those, shall fail with `error-code::read-only` if
+        /// they would otherwise succeed.
+        ///
+        /// This may only be set on directories.
+        mutate-directory,
+    }
+
+    /// File attributes.
+    ///
+    /// Note: This was called `filestat` in earlier versions of WASI.
+    @since(version = 0.2.0)
+    record descriptor-stat {
+        /// File type.
+        %type: descriptor-type,
+        /// Number of hard links to the file.
+        link-count: link-count,
+        /// For regular files, the file size in bytes. For symbolic links, the
+        /// length in bytes of the pathname contained in the symbolic link.
+        size: filesize,
+        /// Last data access timestamp.
+        ///
+        /// If the `option` is none, the platform doesn't maintain an access
+        /// timestamp for this file.
+        data-access-timestamp: option<datetime>,
+        /// Last data modification timestamp.
+        ///
+        /// If the `option` is none, the platform doesn't maintain a
+        /// modification timestamp for this file.
+        data-modification-timestamp: option<datetime>,
+        /// Last file status-change timestamp.
+        ///
+        /// If the `option` is none, the platform doesn't maintain a
+        /// status-change timestamp for this file.
+        status-change-timestamp: option<datetime>,
+    }
+
+    /// Flags determining the method of how paths are resolved.
+    @since(version = 0.2.0)
+    flags path-flags {
+        /// As long as the resolved path corresponds to a symbolic link, it is
+        /// expanded.
+        symlink-follow,
+    }
+
+    /// Open flags used by `open-at`.
+    @since(version = 0.2.0)
+    flags open-flags {
+        /// Create file if it does not exist, similar to `O_CREAT` in POSIX.
+        create,
+        /// Fail if not a directory, similar to `O_DIRECTORY` in POSIX.
+        directory,
+        /// Fail if file already exists, similar to `O_EXCL` in POSIX.
+        exclusive,
+        /// Truncate file to size 0, similar to `O_TRUNC` in POSIX.
+        truncate,
+    }
+
+    /// Number of hard links to an inode.
+    @since(version = 0.2.0)
+    type link-count = u64;
+
+    /// When setting a timestamp, this gives the value to set it to.
+    @since(version = 0.2.0)
+    variant new-timestamp {
+        /// Leave the timestamp set to its previous value.
+        no-change,
+        /// Set the timestamp to the current time of the system clock associated
+        /// with the filesystem.
+        now,
+        /// Set the timestamp to the given value.
+        timestamp(datetime),
+    }
+
+    /// A directory entry.
+    record directory-entry {
+        /// The type of the file referred to by this directory entry.
+        %type: descriptor-type,
+
+        /// The name of the object.
+        name: string,
+    }
+
+    /// Error codes returned by functions, similar to `errno` in POSIX.
+    /// Not all of these error codes are returned by the functions provided by this
+    /// API; some are used in higher-level library layers, and others are provided
+    /// merely for alignment with POSIX.
+    enum error-code {
+        /// Permission denied, similar to `EACCES` in POSIX.
+        access,
+        /// Resource unavailable, or operation would block, similar to `EAGAIN` and `EWOULDBLOCK` in POSIX.
+        would-block,
+        /// Connection already in progress, similar to `EALREADY` in POSIX.
+        already,
+        /// Bad descriptor, similar to `EBADF` in POSIX.
+        bad-descriptor,
+        /// Device or resource busy, similar to `EBUSY` in POSIX.
+        busy,
+        /// Resource deadlock would occur, similar to `EDEADLK` in POSIX.
+        deadlock,
+        /// Storage quota exceeded, similar to `EDQUOT` in POSIX.
+        quota,
+        /// File exists, similar to `EEXIST` in POSIX.
+        exist,
+        /// File too large, similar to `EFBIG` in POSIX.
+        file-too-large,
+        /// Illegal byte sequence, similar to `EILSEQ` in POSIX.
+        illegal-byte-sequence,
+        /// Operation in progress, similar to `EINPROGRESS` in POSIX.
+        in-progress,
+        /// Interrupted function, similar to `EINTR` in POSIX.
+        interrupted,
+        /// Invalid argument, similar to `EINVAL` in POSIX.
+        invalid,
+        /// I/O error, similar to `EIO` in POSIX.
+        io,
+        /// Is a directory, similar to `EISDIR` in POSIX.
+        is-directory,
+        /// Too many levels of symbolic links, similar to `ELOOP` in POSIX.
+        loop,
+        /// Too many links, similar to `EMLINK` in POSIX.
+        too-many-links,
+        /// Message too large, similar to `EMSGSIZE` in POSIX.
+        message-size,
+        /// Filename too long, similar to `ENAMETOOLONG` in POSIX.
+        name-too-long,
+        /// No such device, similar to `ENODEV` in POSIX.
+        no-device,
+        /// No such file or directory, similar to `ENOENT` in POSIX.
+        no-entry,
+        /// No locks available, similar to `ENOLCK` in POSIX.
+        no-lock,
+        /// Not enough space, similar to `ENOMEM` in POSIX.
+        insufficient-memory,
+        /// No space left on device, similar to `ENOSPC` in POSIX.
+        insufficient-space,
+        /// Not a directory or a symbolic link to a directory, similar to `ENOTDIR` in POSIX.
+        not-directory,
+        /// Directory not empty, similar to `ENOTEMPTY` in POSIX.
+        not-empty,
+        /// State not recoverable, similar to `ENOTRECOVERABLE` in POSIX.
+        not-recoverable,
+        /// Not supported, similar to `ENOTSUP` and `ENOSYS` in POSIX.
+        unsupported,
+        /// Inappropriate I/O control operation, similar to `ENOTTY` in POSIX.
+        no-tty,
+        /// No such device or address, similar to `ENXIO` in POSIX.
+        no-such-device,
+        /// Value too large to be stored in data type, similar to `EOVERFLOW` in POSIX.
+        overflow,
+        /// Operation not permitted, similar to `EPERM` in POSIX.
+        not-permitted,
+        /// Broken pipe, similar to `EPIPE` in POSIX.
+        pipe,
+        /// Read-only file system, similar to `EROFS` in POSIX.
+        read-only,
+        /// Invalid seek, similar to `ESPIPE` in POSIX.
+        invalid-seek,
+        /// Text file busy, similar to `ETXTBSY` in POSIX.
+        text-file-busy,
+        /// Cross-device link, similar to `EXDEV` in POSIX.
+        cross-device,
+    }
+
+    /// File or memory access pattern advisory information.
+    @since(version = 0.2.0)
+    enum advice {
+        /// The application has no advice to give on its behavior with respect
+        /// to the specified data.
+        normal,
+        /// The application expects to access the specified data sequentially
+        /// from lower offsets to higher offsets.
+        sequential,
+        /// The application expects to access the specified data in a random
+        /// order.
+        random,
+        /// The application expects to access the specified data in the near
+        /// future.
+        will-need,
+        /// The application expects that it will not access the specified data
+        /// in the near future.
+        dont-need,
+        /// The application expects to access the specified data once and then
+        /// not reuse it thereafter.
+        no-reuse,
+    }
+
+    /// A 128-bit hash value, split into parts because wasm doesn't have a
+    /// 128-bit integer type.
+    @since(version = 0.2.0)
+    record metadata-hash-value {
+       /// 64 bits of a 128-bit hash value.
+       lower: u64,
+       /// Another 64 bits of a 128-bit hash value.
+       upper: u64,
+    }
+
+    /// A descriptor is a reference to a filesystem object, which may be a file,
+    /// directory, named pipe, special file, or other object on which filesystem
+    /// calls may be made.
+    @since(version = 0.2.0)
+    resource descriptor {
+        /// Return a stream for reading from a file, if available.
+        ///
+        /// May fail with an error-code describing why the file cannot be read.
+        ///
+        /// Multiple read, write, and append streams may be active on the same open
+        /// file and they do not interfere with each other.
+        ///
+        /// Note: This allows using `read-stream`, which is similar to `read` in POSIX.
+        @since(version = 0.2.0)
+        read-via-stream: func(
+            /// The offset within the file at which to start reading.
+            offset: filesize,
+        ) -> result<input-stream, error-code>;
+
+        /// Return a stream for writing to a file, if available.
+        ///
+        /// May fail with an error-code describing why the file cannot be written.
+        ///
+        /// Note: This allows using `write-stream`, which is similar to `write` in
+        /// POSIX.
+        @since(version = 0.2.0)
+        write-via-stream: func(
+            /// The offset within the file at which to start writing.
+            offset: filesize,
+        ) -> result<output-stream, error-code>;
+
+        /// Return a stream for appending to a file, if available.
+        ///
+        /// May fail with an error-code describing why the file cannot be appended.
+        ///
+        /// Note: This allows using `write-stream`, which is similar to `write` with
+        /// `O_APPEND` in POSIX.
+        @since(version = 0.2.0)
+        append-via-stream: func() -> result<output-stream, error-code>;
+
+        /// Provide file advisory information on a descriptor.
+        ///
+        /// This is similar to `posix_fadvise` in POSIX.
+        @since(version = 0.2.0)
+        advise: func(
+            /// The offset within the file to which the advisory applies.
+            offset: filesize,
+            /// The length of the region to which the advisory applies.
+            length: filesize,
+            /// The advice.
+            advice: advice
+        ) -> result<_, error-code>;
+
+        /// Synchronize the data of a file to disk.
+        ///
+        /// This function succeeds with no effect if the file descriptor is not
+        /// opened for writing.
+        ///
+        /// Note: This is similar to `fdatasync` in POSIX.
+        @since(version = 0.2.0)
+        sync-data: func() -> result<_, error-code>;
+
+        /// Get flags associated with a descriptor.
+        ///
+        /// Note: This returns similar flags to `fcntl(fd, F_GETFL)` in POSIX.
+        ///
+        /// Note: This returns the value that was the `fs_flags` value returned
+        /// from `fdstat_get` in earlier versions of WASI.
+        @since(version = 0.2.0)
+        get-flags: func() -> result<descriptor-flags, error-code>;
+
+        /// Get the dynamic type of a descriptor.
+        ///
+        /// Note: This returns the same value as the `type` field of the `fd-stat`
+        /// returned by `stat`, `stat-at` and similar.
+        ///
+        /// Note: This returns similar flags to the `st_mode & S_IFMT` value provided
+        /// by `fstat` in POSIX.
+        ///
+        /// Note: This returns the value that was the `fs_filetype` value returned
+        /// from `fdstat_get` in earlier versions of WASI.
+        @since(version = 0.2.0)
+        get-type: func() -> result<descriptor-type, error-code>;
+
+        /// Adjust the size of an open file. If this increases the file's size, the
+        /// extra bytes are filled with zeros.
+        ///
+        /// Note: This was called `fd_filestat_set_size` in earlier versions of WASI.
+        @since(version = 0.2.0)
+        set-size: func(size: filesize) -> result<_, error-code>;
+
+        /// Adjust the timestamps of an open file or directory.
+        ///
+        /// Note: This is similar to `futimens` in POSIX.
+        ///
+        /// Note: This was called `fd_filestat_set_times` in earlier versions of WASI.
+        @since(version = 0.2.0)
+        set-times: func(
+            /// The desired values of the data access timestamp.
+            data-access-timestamp: new-timestamp,
+            /// The desired values of the data modification timestamp.
+            data-modification-timestamp: new-timestamp,
+        ) -> result<_, error-code>;
+
+        /// Read from a descriptor, without using and updating the descriptor's offset.
+        ///
+        /// This function returns a list of bytes containing the data that was
+        /// read, along with a bool which, when true, indicates that the end of the
+        /// file was reached. The returned list will contain up to `length` bytes; it
+        /// may return fewer than requested, if the end of the file is reached or
+        /// if the I/O operation is interrupted.
+        ///
+        /// In the future, this may change to return a `stream<u8, error-code>`.
+        ///
+        /// Note: This is similar to `pread` in POSIX.
+        @since(version = 0.2.0)
+        read: func(
+            /// The maximum number of bytes to read.
+            length: filesize,
+            /// The offset within the file at which to read.
+            offset: filesize,
+        ) -> result<tuple<list<u8>, bool>, error-code>;
+
+        /// Write to a descriptor, without using and updating the descriptor's offset.
+        ///
+        /// It is valid to write past the end of a file; the file is extended to the
+        /// extent of the write, with bytes between the previous end and the start of
+        /// the write set to zero.
+        ///
+        /// In the future, this may change to take a `stream<u8, error-code>`.
+        ///
+        /// Note: This is similar to `pwrite` in POSIX.
+        @since(version = 0.2.0)
+        write: func(
+            /// Data to write
+            buffer: list<u8>,
+            /// The offset within the file at which to write.
+            offset: filesize,
+        ) -> result<filesize, error-code>;
+
+        /// Read directory entries from a directory.
+        ///
+        /// On filesystems where directories contain entries referring to themselves
+        /// and their parents, often named `.` and `..` respectively, these entries
+        /// are omitted.
+        ///
+        /// This always returns a new stream which starts at the beginning of the
+        /// directory. Multiple streams may be active on the same directory, and they
+        /// do not interfere with each other.
+        @since(version = 0.2.0)
+        read-directory: func() -> result<directory-entry-stream, error-code>;
+
+        /// Synchronize the data and metadata of a file to disk.
+        ///
+        /// This function succeeds with no effect if the file descriptor is not
+        /// opened for writing.
+        ///
+        /// Note: This is similar to `fsync` in POSIX.
+        @since(version = 0.2.0)
+        sync: func() -> result<_, error-code>;
+
+        /// Create a directory.
+        ///
+        /// Note: This is similar to `mkdirat` in POSIX.
+        @since(version = 0.2.0)
+        create-directory-at: func(
+            /// The relative path at which to create the directory.
+            path: string,
+        ) -> result<_, error-code>;
+
+        /// Return the attributes of an open file or directory.
+        ///
+        /// Note: This is similar to `fstat` in POSIX, except that it does not return
+        /// device and inode information. For testing whether two descriptors refer to
+        /// the same underlying filesystem object, use `is-same-object`. To obtain
+        /// additional data that can be used do determine whether a file has been
+        /// modified, use `metadata-hash`.
+        ///
+        /// Note: This was called `fd_filestat_get` in earlier versions of WASI.
+        @since(version = 0.2.0)
+        stat: func() -> result<descriptor-stat, error-code>;
+
+        /// Return the attributes of a file or directory.
+        ///
+        /// Note: This is similar to `fstatat` in POSIX, except that it does not
+        /// return device and inode information. See the `stat` description for a
+        /// discussion of alternatives.
+        ///
+        /// Note: This was called `path_filestat_get` in earlier versions of WASI.
+        @since(version = 0.2.0)
+        stat-at: func(
+            /// Flags determining the method of how the path is resolved.
+            path-flags: path-flags,
+            /// The relative path of the file or directory to inspect.
+            path: string,
+        ) -> result<descriptor-stat, error-code>;
+
+        /// Adjust the timestamps of a file or directory.
+        ///
+        /// Note: This is similar to `utimensat` in POSIX.
+        ///
+        /// Note: This was called `path_filestat_set_times` in earlier versions of
+        /// WASI.
+        @since(version = 0.2.0)
+        set-times-at: func(
+            /// Flags determining the method of how the path is resolved.
+            path-flags: path-flags,
+            /// The relative path of the file or directory to operate on.
+            path: string,
+            /// The desired values of the data access timestamp.
+            data-access-timestamp: new-timestamp,
+            /// The desired values of the data modification timestamp.
+            data-modification-timestamp: new-timestamp,
+        ) -> result<_, error-code>;
+
+        /// Create a hard link.
+        ///
+        /// Note: This is similar to `linkat` in POSIX.
+        @since(version = 0.2.0)
+        link-at: func(
+            /// Flags determining the method of how the path is resolved.
+            old-path-flags: path-flags,
+            /// The relative source path from which to link.
+            old-path: string,
+            /// The base directory for `new-path`.
+            new-descriptor: borrow<descriptor>,
+            /// The relative destination path at which to create the hard link.
+            new-path: string,
+        ) -> result<_, error-code>;
+
+        /// Open a file or directory.
+        ///
+        /// If `flags` contains `descriptor-flags::mutate-directory`, and the base
+        /// descriptor doesn't have `descriptor-flags::mutate-directory` set,
+        /// `open-at` fails with `error-code::read-only`.
+        ///
+        /// If `flags` contains `write` or `mutate-directory`, or `open-flags`
+        /// contains `truncate` or `create`, and the base descriptor doesn't have
+        /// `descriptor-flags::mutate-directory` set, `open-at` fails with
+        /// `error-code::read-only`.
+        ///
+        /// Note: This is similar to `openat` in POSIX.
+        @since(version = 0.2.0)
+        open-at: func(
+            /// Flags determining the method of how the path is resolved.
+            path-flags: path-flags,
+            /// The relative path of the object to open.
+            path: string,
+            /// The method by which to open the file.
+            open-flags: open-flags,
+            /// Flags to use for the resulting descriptor.
+            %flags: descriptor-flags,
+        ) -> result<descriptor, error-code>;
+
+        /// Read the contents of a symbolic link.
+        ///
+        /// If the contents contain an absolute or rooted path in the underlying
+        /// filesystem, this function fails with `error-code::not-permitted`.
+        ///
+        /// Note: This is similar to `readlinkat` in POSIX.
+        @since(version = 0.2.0)
+        readlink-at: func(
+            /// The relative path of the symbolic link from which to read.
+            path: string,
+        ) -> result<string, error-code>;
+
+        /// Remove a directory.
+        ///
+        /// Return `error-code::not-empty` if the directory is not empty.
+        ///
+        /// Note: This is similar to `unlinkat(fd, path, AT_REMOVEDIR)` in POSIX.
+        @since(version = 0.2.0)
+        remove-directory-at: func(
+            /// The relative path to a directory to remove.
+            path: string,
+        ) -> result<_, error-code>;
+
+        /// Rename a filesystem object.
+        ///
+        /// Note: This is similar to `renameat` in POSIX.
+        @since(version = 0.2.0)
+        rename-at: func(
+            /// The relative source path of the file or directory to rename.
+            old-path: string,
+            /// The base directory for `new-path`.
+            new-descriptor: borrow<descriptor>,
+            /// The relative destination path to which to rename the file or directory.
+            new-path: string,
+        ) -> result<_, error-code>;
+
+        /// Create a symbolic link (also known as a "symlink").
+        ///
+        /// If `old-path` starts with `/`, the function fails with
+        /// `error-code::not-permitted`.
+        ///
+        /// Note: This is similar to `symlinkat` in POSIX.
+        @since(version = 0.2.0)
+        symlink-at: func(
+            /// The contents of the symbolic link.
+            old-path: string,
+            /// The relative destination path at which to create the symbolic link.
+            new-path: string,
+        ) -> result<_, error-code>;
+
+        /// Unlink a filesystem object that is not a directory.
+        ///
+        /// Return `error-code::is-directory` if the path refers to a directory.
+        /// Note: This is similar to `unlinkat(fd, path, 0)` in POSIX.
+        @since(version = 0.2.0)
+        unlink-file-at: func(
+            /// The relative path to a file to unlink.
+            path: string,
+        ) -> result<_, error-code>;
+
+        /// Test whether two descriptors refer to the same filesystem object.
+        ///
+        /// In POSIX, this corresponds to testing whether the two descriptors have the
+        /// same device (`st_dev`) and inode (`st_ino` or `d_ino`) numbers.
+        /// wasi-filesystem does not expose device and inode numbers, so this function
+        /// may be used instead.
+        @since(version = 0.2.0)
+        is-same-object: func(other: borrow<descriptor>) -> bool;
+
+        /// Return a hash of the metadata associated with a filesystem object referred
+        /// to by a descriptor.
+        ///
+        /// This returns a hash of the last-modification timestamp and file size, and
+        /// may also include the inode number, device number, birth timestamp, and
+        /// other metadata fields that may change when the file is modified or
+        /// replaced. It may also include a secret value chosen by the
+        /// implementation and not otherwise exposed.
+        ///
+        /// Implementations are encouraged to provide the following properties:
+        ///
+        ///  - If the file is not modified or replaced, the computed hash value should
+        ///    usually not change.
+        ///  - If the object is modified or replaced, the computed hash value should
+        ///    usually change.
+        ///  - The inputs to the hash should not be easily computable from the
+        ///    computed hash.
+        ///
+        /// However, none of these is required.
+        @since(version = 0.2.0)
+        metadata-hash: func() -> result<metadata-hash-value, error-code>;
+
+        /// Return a hash of the metadata associated with a filesystem object referred
+        /// to by a directory descriptor and a relative path.
+        ///
+        /// This performs the same hash computation as `metadata-hash`.
+        @since(version = 0.2.0)
+        metadata-hash-at: func(
+            /// Flags determining the method of how the path is resolved.
+            path-flags: path-flags,
+            /// The relative path of the file or directory to inspect.
+            path: string,
+        ) -> result<metadata-hash-value, error-code>;
+    }
+
+    /// A stream of directory entries.
+    @since(version = 0.2.0)
+    resource directory-entry-stream {
+        /// Read a single directory entry from a `directory-entry-stream`.
+        @since(version = 0.2.0)
+        read-directory-entry: func() -> result<option<directory-entry>, error-code>;
+    }
+
+    /// Attempts to extract a filesystem-related `error-code` from the stream
+    /// `error` provided.
+    ///
+    /// Stream operations which return `stream-error::last-operation-failed`
+    /// have a payload with more information about the operation that failed.
+    /// This payload can be passed through to this function to see if there's
+    /// filesystem-related information about the error to return.
+    ///
+    /// Note that this function is fallible because not all stream-related
+    /// errors are filesystem-related errors.
+    @since(version = 0.2.0)
+    filesystem-error-code: func(err: borrow<error>) -> option<error-code>;
+}

guests/typescript/wit/deps/filesystem/world.wit

@@ -0,0 +1,9 @@
+package wasi:filesystem@0.2.3;
+
+@since(version = 0.2.0)
+world imports {
+    @since(version = 0.2.0)
+    import types;
+    @since(version = 0.2.0)
+    import preopens;
+}

guests/typescript/wit/deps/http/handler.wit

@@ -0,0 +1,49 @@
+/// This interface defines a handler of incoming HTTP Requests. It should
+/// be exported by components which can respond to HTTP Requests.
+@since(version = 0.2.0)
+interface incoming-handler {
+  @since(version = 0.2.0)
+  use types.{incoming-request, response-outparam};
+
+  /// This function is invoked with an incoming HTTP Request, and a resource
+  /// `response-outparam` which provides the capability to reply with an HTTP
+  /// Response. The response is sent by calling the `response-outparam.set`
+  /// method, which allows execution to continue after the response has been
+  /// sent. This enables both streaming to the response body, and performing other
+  /// work.
+  ///
+  /// The implementor of this function must write a response to the
+  /// `response-outparam` before returning, or else the caller will respond
+  /// with an error on its behalf.
+  @since(version = 0.2.0)
+  handle: func(
+    request: incoming-request,
+    response-out: response-outparam
+  );
+}
+
+/// This interface defines a handler of outgoing HTTP Requests. It should be
+/// imported by components which wish to make HTTP Requests.
+@since(version = 0.2.0)
+interface outgoing-handler {
+  @since(version = 0.2.0)
+  use types.{
+    outgoing-request, request-options, future-incoming-response, error-code
+  };
+
+  /// This function is invoked with an outgoing HTTP Request, and it returns
+  /// a resource `future-incoming-response` which represents an HTTP Response
+  /// which may arrive in the future.
+  ///
+  /// The `options` argument accepts optional parameters for the HTTP
+  /// protocol's transport layer.
+  ///
+  /// This function may return an error if the `outgoing-request` is invalid
+  /// or not allowed to be made. Otherwise, protocol errors are reported
+  /// through the `future-incoming-response`.
+  @since(version = 0.2.0)
+  handle: func(
+    request: outgoing-request,
+    options: option<request-options>
+  ) -> result<future-incoming-response, error-code>;
+}

guests/typescript/wit/deps/http/proxy.wit

@@ -0,0 +1,50 @@
+package wasi:http@0.2.3;
+
+/// The `wasi:http/imports` world imports all the APIs for HTTP proxies.
+/// It is intended to be `include`d in other worlds.
+@since(version = 0.2.0)
+world imports {
+  /// HTTP proxies have access to time and randomness.
+  @since(version = 0.2.0)
+  import wasi:clocks/monotonic-clock@0.2.3;
+  @since(version = 0.2.0)
+  import wasi:clocks/wall-clock@0.2.3;
+  @since(version = 0.2.0)
+  import wasi:random/random@0.2.3;
+
+  /// Proxies have standard output and error streams which are expected to
+  /// terminate in a developer-facing console provided by the host.
+  @since(version = 0.2.0)
+  import wasi:cli/stdout@0.2.3;
+  @since(version = 0.2.0)
+  import wasi:cli/stderr@0.2.3;
+
+  /// TODO: this is a temporary workaround until component tooling is able to
+  /// gracefully handle the absence of stdin. Hosts must return an eof stream
+  /// for this import, which is what wasi-libc + tooling will do automatically
+  /// when this import is properly removed.
+  @since(version = 0.2.0)
+  import wasi:cli/stdin@0.2.3;
+
+  /// This is the default handler to use when user code simply wants to make an
+  /// HTTP request (e.g., via `fetch()`).
+  @since(version = 0.2.0)
+  import outgoing-handler;
+}
+
+/// The `wasi:http/proxy` world captures a widely-implementable intersection of
+/// hosts that includes HTTP forward and reverse proxies. Components targeting
+/// this world may concurrently stream in and out any number of incoming and
+/// outgoing HTTP requests.
+@since(version = 0.2.0)
+world proxy {
+  @since(version = 0.2.0)
+  include imports;
+
+  /// The host delivers incoming HTTP requests to a component by calling the
+  /// `handle` function of this exported interface. A host may arbitrarily reuse
+  /// or not reuse component instance when delivering incoming HTTP requests and
+  /// thus a component must be able to handle 0..N calls to `handle`.
+  @since(version = 0.2.0)
+  export incoming-handler;
+}

guests/typescript/wit/deps/http/types.wit

@@ -0,0 +1,673 @@
+/// This interface defines all of the types and methods for implementing
+/// HTTP Requests and Responses, both incoming and outgoing, as well as
+/// their headers, trailers, and bodies.
+@since(version = 0.2.0)
+interface types {
+  @since(version = 0.2.0)
+  use wasi:clocks/monotonic-clock@0.2.3.{duration};
+  @since(version = 0.2.0)
+  use wasi:io/streams@0.2.3.{input-stream, output-stream};
+  @since(version = 0.2.0)
+  use wasi:io/error@0.2.3.{error as io-error};
+  @since(version = 0.2.0)
+  use wasi:io/poll@0.2.3.{pollable};
+
+  /// This type corresponds to HTTP standard Methods.
+  @since(version = 0.2.0)
+  variant method {
+    get,
+    head,
+    post,
+    put,
+    delete,
+    connect,
+    options,
+    trace,
+    patch,
+    other(string)
+  }
+
+  /// This type corresponds to HTTP standard Related Schemes.
+  @since(version = 0.2.0)
+  variant scheme {
+    HTTP,
+    HTTPS,
+    other(string)
+  }
+
+  /// These cases are inspired by the IANA HTTP Proxy Error Types:
+  ///   <https://www.iana.org/assignments/http-proxy-status/http-proxy-status.xhtml#table-http-proxy-error-types>
+  @since(version = 0.2.0)
+  variant error-code {
+    DNS-timeout,
+    DNS-error(DNS-error-payload),
+    destination-not-found,
+    destination-unavailable,
+    destination-IP-prohibited,
+    destination-IP-unroutable,
+    connection-refused,
+    connection-terminated,
+    connection-timeout,
+    connection-read-timeout,
+    connection-write-timeout,
+    connection-limit-reached,
+    TLS-protocol-error,
+    TLS-certificate-error,
+    TLS-alert-received(TLS-alert-received-payload),
+    HTTP-request-denied,
+    HTTP-request-length-required,
+    HTTP-request-body-size(option<u64>),
+    HTTP-request-method-invalid,
+    HTTP-request-URI-invalid,
+    HTTP-request-URI-too-long,
+    HTTP-request-header-section-size(option<u32>),
+    HTTP-request-header-size(option<field-size-payload>),
+    HTTP-request-trailer-section-size(option<u32>),
+    HTTP-request-trailer-size(field-size-payload),
+    HTTP-response-incomplete,
+    HTTP-response-header-section-size(option<u32>),
+    HTTP-response-header-size(field-size-payload),
+    HTTP-response-body-size(option<u64>),
+    HTTP-response-trailer-section-size(option<u32>),
+    HTTP-response-trailer-size(field-size-payload),
+    HTTP-response-transfer-coding(option<string>),
+    HTTP-response-content-coding(option<string>),
+    HTTP-response-timeout,
+    HTTP-upgrade-failed,
+    HTTP-protocol-error,
+    loop-detected,
+    configuration-error,
+    /// This is a catch-all error for anything that doesn't fit cleanly into a
+    /// more specific case. It also includes an optional string for an
+    /// unstructured description of the error. Users should not depend on the
+    /// string for diagnosing errors, as it's not required to be consistent
+    /// between implementations.
+    internal-error(option<string>)
+  }
+
+  /// Defines the case payload type for `DNS-error` above:
+  @since(version = 0.2.0)
+  record DNS-error-payload {
+    rcode: option<string>,
+    info-code: option<u16>
+  }
+
+  /// Defines the case payload type for `TLS-alert-received` above:
+  @since(version = 0.2.0)
+  record TLS-alert-received-payload {
+    alert-id: option<u8>,
+    alert-message: option<string>
+  }
+
+  /// Defines the case payload type for `HTTP-response-{header,trailer}-size` above:
+  @since(version = 0.2.0)
+  record field-size-payload {
+    field-name: option<string>,
+    field-size: option<u32>
+  }
+
+  /// Attempts to extract a http-related `error` from the wasi:io `error`
+  /// provided.
+  ///
+  /// Stream operations which return
+  /// `wasi:io/stream/stream-error::last-operation-failed` have a payload of
+  /// type `wasi:io/error/error` with more information about the operation
+  /// that failed. This payload can be passed through to this function to see
+  /// if there's http-related information about the error to return.
+  ///
+  /// Note that this function is fallible because not all io-errors are
+  /// http-related errors.
+  @since(version = 0.2.0)
+  http-error-code: func(err: borrow<io-error>) -> option<error-code>;
+
+  /// This type enumerates the different kinds of errors that may occur when
+  /// setting or appending to a `fields` resource.
+  @since(version = 0.2.0)
+  variant header-error {
+    /// This error indicates that a `field-name` or `field-value` was
+    /// syntactically invalid when used with an operation that sets headers in a
+    /// `fields`.
+    invalid-syntax,
+
+    /// This error indicates that a forbidden `field-name` was used when trying
+    /// to set a header in a `fields`.
+    forbidden,
+
+    /// This error indicates that the operation on the `fields` was not
+    /// permitted because the fields are immutable.
+    immutable,
+  }
+
+  /// Field names are always strings.
+  ///
+  /// Field names should always be treated as case insensitive by the `fields`
+  /// resource for the purposes of equality checking.
+  @since(version = 0.2.1)
+  type field-name = field-key;
+
+  /// Field keys are always strings.
+  ///
+  /// Field keys should always be treated as case insensitive by the `fields`
+  /// resource for the purposes of equality checking.
+  ///
+  /// # Deprecation
+  ///
+  /// This type has been deprecated in favor of the `field-name` type.
+  @since(version = 0.2.0)
+  @deprecated(version = 0.2.2)
+  type field-key = string;
+
+  /// Field values should always be ASCII strings. However, in
+  /// reality, HTTP implementations often have to interpret malformed values,
+  /// so they are provided as a list of bytes.
+  @since(version = 0.2.0)
+  type field-value = list<u8>;
+
+  /// This following block defines the `fields` resource which corresponds to
+  /// HTTP standard Fields. Fields are a common representation used for both
+  /// Headers and Trailers.
+  ///
+  /// A `fields` may be mutable or immutable. A `fields` created using the
+  /// constructor, `from-list`, or `clone` will be mutable, but a `fields`
+  /// resource given by other means (including, but not limited to,
+  /// `incoming-request.headers`, `outgoing-request.headers`) might be be
+  /// immutable. In an immutable fields, the `set`, `append`, and `delete`
+  /// operations will fail with `header-error.immutable`.
+  @since(version = 0.2.0)
+  resource fields {
+
+    /// Construct an empty HTTP Fields.
+    ///
+    /// The resulting `fields` is mutable.
+    @since(version = 0.2.0)
+    constructor();
+
+    /// Construct an HTTP Fields.
+    ///
+    /// The resulting `fields` is mutable.
+    ///
+    /// The list represents each name-value pair in the Fields. Names
+    /// which have multiple values are represented by multiple entries in this
+    /// list with the same name.
+    ///
+    /// The tuple is a pair of the field name, represented as a string, and
+    /// Value, represented as a list of bytes.
+    ///
+    /// An error result will be returned if any `field-name` or `field-value` is
+    /// syntactically invalid, or if a field is forbidden.
+    @since(version = 0.2.0)
+    from-list: static func(
+      entries: list<tuple<field-name,field-value>>
+    ) -> result<fields, header-error>;
+
+    /// Get all of the values corresponding to a name. If the name is not present
+    /// in this `fields` or is syntactically invalid, an empty list is returned.
+    /// However, if the name is present but empty, this is represented by a list
+    /// with one or more empty field-values present.
+    @since(version = 0.2.0)
+    get: func(name: field-name) -> list<field-value>;
+
+    /// Returns `true` when the name is present in this `fields`. If the name is
+    /// syntactically invalid, `false` is returned.
+    @since(version = 0.2.0)
+    has: func(name: field-name) -> bool;
+
+    /// Set all of the values for a name. Clears any existing values for that
+    /// name, if they have been set.
+    ///
+    /// Fails with `header-error.immutable` if the `fields` are immutable.
+    ///
+    /// Fails with `header-error.invalid-syntax` if the `field-name` or any of
+    /// the `field-value`s are syntactically invalid.
+    @since(version = 0.2.0)
+    set: func(name: field-name, value: list<field-value>) -> result<_, header-error>;
+
+    /// Delete all values for a name. Does nothing if no values for the name
+    /// exist.
+    ///
+    /// Fails with `header-error.immutable` if the `fields` are immutable.
+    ///
+    /// Fails with `header-error.invalid-syntax` if the `field-name` is
+    /// syntactically invalid.
+    @since(version = 0.2.0)
+    delete: func(name: field-name) -> result<_, header-error>;
+
+    /// Append a value for a name. Does not change or delete any existing
+    /// values for that name.
+    ///
+    /// Fails with `header-error.immutable` if the `fields` are immutable.
+    ///
+    /// Fails with `header-error.invalid-syntax` if the `field-name` or
+    /// `field-value` are syntactically invalid.
+    @since(version = 0.2.0)
+    append: func(name: field-name, value: field-value) -> result<_, header-error>;
+
+    /// Retrieve the full set of names and values in the Fields. Like the
+    /// constructor, the list represents each name-value pair.
+    ///
+    /// The outer list represents each name-value pair in the Fields. Names
+    /// which have multiple values are represented by multiple entries in this
+    /// list with the same name.
+    ///
+    /// The names and values are always returned in the original casing and in
+    /// the order in which they will be serialized for transport.
+    @since(version = 0.2.0)
+    entries: func() -> list<tuple<field-name,field-value>>;
+
+    /// Make a deep copy of the Fields. Equivalent in behavior to calling the
+    /// `fields` constructor on the return value of `entries`. The resulting
+    /// `fields` is mutable.
+    @since(version = 0.2.0)
+    clone: func() -> fields;
+  }
+
+  /// Headers is an alias for Fields.
+  @since(version = 0.2.0)
+  type headers = fields;
+
+  /// Trailers is an alias for Fields.
+  @since(version = 0.2.0)
+  type trailers = fields;
+
+  /// Represents an incoming HTTP Request.
+  @since(version = 0.2.0)
+  resource incoming-request {
+
+    /// Returns the method of the incoming request.
+    @since(version = 0.2.0)
+    method: func() -> method;
+
+    /// Returns the path with query parameters from the request, as a string.
+    @since(version = 0.2.0)
+    path-with-query: func() -> option<string>;
+
+    /// Returns the protocol scheme from the request.
+    @since(version = 0.2.0)
+    scheme: func() -> option<scheme>;
+
+    /// Returns the authority of the Request's target URI, if present.
+    @since(version = 0.2.0)
+    authority: func() -> option<string>;
+
+    /// Get the `headers` associated with the request.
+    ///
+    /// The returned `headers` resource is immutable: `set`, `append`, and
+    /// `delete` operations will fail with `header-error.immutable`.
+    ///
+    /// The `headers` returned are a child resource: it must be dropped before
+    /// the parent `incoming-request` is dropped. Dropping this
+    /// `incoming-request` before all children are dropped will trap.
+    @since(version = 0.2.0)
+    headers: func() -> headers;
+
+    /// Gives the `incoming-body` associated with this request. Will only
+    /// return success at most once, and subsequent calls will return error.
+    @since(version = 0.2.0)
+    consume: func() -> result<incoming-body>;
+  }
+
+  /// Represents an outgoing HTTP Request.
+  @since(version = 0.2.0)
+  resource outgoing-request {
+
+    /// Construct a new `outgoing-request` with a default `method` of `GET`, and
+    /// `none` values for `path-with-query`, `scheme`, and `authority`.
+    ///
+    /// * `headers` is the HTTP Headers for the Request.
+    ///
+    /// It is possible to construct, or manipulate with the accessor functions
+    /// below, an `outgoing-request` with an invalid combination of `scheme`
+    /// and `authority`, or `headers` which are not permitted to be sent.
+    /// It is the obligation of the `outgoing-handler.handle` implementation
+    /// to reject invalid constructions of `outgoing-request`.
+    @since(version = 0.2.0)
+    constructor(
+      headers: headers
+    );
+
+    /// Returns the resource corresponding to the outgoing Body for this
+    /// Request.
+    ///
+    /// Returns success on the first call: the `outgoing-body` resource for
+    /// this `outgoing-request` can be retrieved at most once. Subsequent
+    /// calls will return error.
+    @since(version = 0.2.0)
+    body: func() -> result<outgoing-body>;
+
+    /// Get the Method for the Request.
+    @since(version = 0.2.0)
+    method: func() -> method;
+    /// Set the Method for the Request. Fails if the string present in a
+    /// `method.other` argument is not a syntactically valid method.
+    @since(version = 0.2.0)
+    set-method: func(method: method) -> result;
+
+    /// Get the combination of the HTTP Path and Query for the Request.
+    /// When `none`, this represents an empty Path and empty Query.
+    @since(version = 0.2.0)
+    path-with-query: func() -> option<string>;
+    /// Set the combination of the HTTP Path and Query for the Request.
+    /// When `none`, this represents an empty Path and empty Query. Fails is the
+    /// string given is not a syntactically valid path and query uri component.
+    @since(version = 0.2.0)
+    set-path-with-query: func(path-with-query: option<string>) -> result;
+
+    /// Get the HTTP Related Scheme for the Request. When `none`, the
+    /// implementation may choose an appropriate default scheme.
+    @since(version = 0.2.0)
+    scheme: func() -> option<scheme>;
+    /// Set the HTTP Related Scheme for the Request. When `none`, the
+    /// implementation may choose an appropriate default scheme. Fails if the
+    /// string given is not a syntactically valid uri scheme.
+    @since(version = 0.2.0)
+    set-scheme: func(scheme: option<scheme>) -> result;
+
+    /// Get the authority of the Request's target URI. A value of `none` may be used
+    /// with Related Schemes which do not require an authority. The HTTP and
+    /// HTTPS schemes always require an authority.
+    @since(version = 0.2.0)
+    authority: func() -> option<string>;
+    /// Set the authority of the Request's target URI. A value of `none` may be used
+    /// with Related Schemes which do not require an authority. The HTTP and
+    /// HTTPS schemes always require an authority. Fails if the string given is
+    /// not a syntactically valid URI authority.
+    @since(version = 0.2.0)
+    set-authority: func(authority: option<string>) -> result;
+
+    /// Get the headers associated with the Request.
+    ///
+    /// The returned `headers` resource is immutable: `set`, `append`, and
+    /// `delete` operations will fail with `header-error.immutable`.
+    ///
+    /// This headers resource is a child: it must be dropped before the parent
+    /// `outgoing-request` is dropped, or its ownership is transferred to
+    /// another component by e.g. `outgoing-handler.handle`.
+    @since(version = 0.2.0)
+    headers: func() -> headers;
+  }
+
+  /// Parameters for making an HTTP Request. Each of these parameters is
+  /// currently an optional timeout applicable to the transport layer of the
+  /// HTTP protocol.
+  ///
+  /// These timeouts are separate from any the user may use to bound a
+  /// blocking call to `wasi:io/poll.poll`.
+  @since(version = 0.2.0)
+  resource request-options {
+    /// Construct a default `request-options` value.
+    @since(version = 0.2.0)
+    constructor();
+
+    /// The timeout for the initial connect to the HTTP Server.
+    @since(version = 0.2.0)
+    connect-timeout: func() -> option<duration>;
+
+    /// Set the timeout for the initial connect to the HTTP Server. An error
+    /// return value indicates that this timeout is not supported.
+    @since(version = 0.2.0)
+    set-connect-timeout: func(duration: option<duration>) -> result;
+
+    /// The timeout for receiving the first byte of the Response body.
+    @since(version = 0.2.0)
+    first-byte-timeout: func() -> option<duration>;
+
+    /// Set the timeout for receiving the first byte of the Response body. An
+    /// error return value indicates that this timeout is not supported.
+    @since(version = 0.2.0)
+    set-first-byte-timeout: func(duration: option<duration>) -> result;
+
+    /// The timeout for receiving subsequent chunks of bytes in the Response
+    /// body stream.
+    @since(version = 0.2.0)
+    between-bytes-timeout: func() -> option<duration>;
+
+    /// Set the timeout for receiving subsequent chunks of bytes in the Response
+    /// body stream. An error return value indicates that this timeout is not
+    /// supported.
+    @since(version = 0.2.0)
+    set-between-bytes-timeout: func(duration: option<duration>) -> result;
+  }
+
+  /// Represents the ability to send an HTTP Response.
+  ///
+  /// This resource is used by the `wasi:http/incoming-handler` interface to
+  /// allow a Response to be sent corresponding to the Request provided as the
+  /// other argument to `incoming-handler.handle`.
+  @since(version = 0.2.0)
+  resource response-outparam {
+
+    /// Set the value of the `response-outparam` to either send a response,
+    /// or indicate an error.
+    ///
+    /// This method consumes the `response-outparam` to ensure that it is
+    /// called at most once. If it is never called, the implementation
+    /// will respond with an error.
+    ///
+    /// The user may provide an `error` to `response` to allow the
+    /// implementation determine how to respond with an HTTP error response.
+    @since(version = 0.2.0)
+    set: static func(
+      param: response-outparam,
+      response: result<outgoing-response, error-code>,
+    );
+  }
+
+  /// This type corresponds to the HTTP standard Status Code.
+  @since(version = 0.2.0)
+  type status-code = u16;
+
+  /// Represents an incoming HTTP Response.
+  @since(version = 0.2.0)
+  resource incoming-response {
+
+    /// Returns the status code from the incoming response.
+    @since(version = 0.2.0)
+    status: func() -> status-code;
+
+    /// Returns the headers from the incoming response.
+    ///
+    /// The returned `headers` resource is immutable: `set`, `append`, and
+    /// `delete` operations will fail with `header-error.immutable`.
+    ///
+    /// This headers resource is a child: it must be dropped before the parent
+    /// `incoming-response` is dropped.
+    @since(version = 0.2.0)
+    headers: func() -> headers;
+
+    /// Returns the incoming body. May be called at most once. Returns error
+    /// if called additional times.
+    @since(version = 0.2.0)
+    consume: func() -> result<incoming-body>;
+  }
+
+  /// Represents an incoming HTTP Request or Response's Body.
+  ///
+  /// A body has both its contents - a stream of bytes - and a (possibly
+  /// empty) set of trailers, indicating that the full contents of the
+  /// body have been received. This resource represents the contents as
+  /// an `input-stream` and the delivery of trailers as a `future-trailers`,
+  /// and ensures that the user of this interface may only be consuming either
+  /// the body contents or waiting on trailers at any given time.
+  @since(version = 0.2.0)
+  resource incoming-body {
+
+    /// Returns the contents of the body, as a stream of bytes.
+    ///
+    /// Returns success on first call: the stream representing the contents
+    /// can be retrieved at most once. Subsequent calls will return error.
+    ///
+    /// The returned `input-stream` resource is a child: it must be dropped
+    /// before the parent `incoming-body` is dropped, or consumed by
+    /// `incoming-body.finish`.
+    ///
+    /// This invariant ensures that the implementation can determine whether
+    /// the user is consuming the contents of the body, waiting on the
+    /// `future-trailers` to be ready, or neither. This allows for network
+    /// backpressure is to be applied when the user is consuming the body,
+    /// and for that backpressure to not inhibit delivery of the trailers if
+    /// the user does not read the entire body.
+    @since(version = 0.2.0)
+    %stream: func() -> result<input-stream>;
+
+    /// Takes ownership of `incoming-body`, and returns a `future-trailers`.
+    /// This function will trap if the `input-stream` child is still alive.
+    @since(version = 0.2.0)
+    finish: static func(this: incoming-body) -> future-trailers;
+  }
+
+  /// Represents a future which may eventually return trailers, or an error.
+  ///
+  /// In the case that the incoming HTTP Request or Response did not have any
+  /// trailers, this future will resolve to the empty set of trailers once the
+  /// complete Request or Response body has been received.
+  @since(version = 0.2.0)
+  resource future-trailers {
+
+    /// Returns a pollable which becomes ready when either the trailers have
+    /// been received, or an error has occurred. When this pollable is ready,
+    /// the `get` method will return `some`.
+    @since(version = 0.2.0)
+    subscribe: func() -> pollable;
+
+    /// Returns the contents of the trailers, or an error which occurred,
+    /// once the future is ready.
+    ///
+    /// The outer `option` represents future readiness. Users can wait on this
+    /// `option` to become `some` using the `subscribe` method.
+    ///
+    /// The outer `result` is used to retrieve the trailers or error at most
+    /// once. It will be success on the first call in which the outer option
+    /// is `some`, and error on subsequent calls.
+    ///
+    /// The inner `result` represents that either the HTTP Request or Response
+    /// body, as well as any trailers, were received successfully, or that an
+    /// error occurred receiving them. The optional `trailers` indicates whether
+    /// or not trailers were present in the body.
+    ///
+    /// When some `trailers` are returned by this method, the `trailers`
+    /// resource is immutable, and a child. Use of the `set`, `append`, or
+    /// `delete` methods will return an error, and the resource must be
+    /// dropped before the parent `future-trailers` is dropped.
+    @since(version = 0.2.0)
+    get: func() -> option<result<result<option<trailers>, error-code>>>;
+  }
+
+  /// Represents an outgoing HTTP Response.
+  @since(version = 0.2.0)
+  resource outgoing-response {
+
+    /// Construct an `outgoing-response`, with a default `status-code` of `200`.
+    /// If a different `status-code` is needed, it must be set via the
+    /// `set-status-code` method.
+    ///
+    /// * `headers` is the HTTP Headers for the Response.
+    @since(version = 0.2.0)
+    constructor(headers: headers);
+
+    /// Get the HTTP Status Code for the Response.
+    @since(version = 0.2.0)
+    status-code: func() -> status-code;
+
+    /// Set the HTTP Status Code for the Response. Fails if the status-code
+    /// given is not a valid http status code.
+    @since(version = 0.2.0)
+    set-status-code: func(status-code: status-code) -> result;
+
+    /// Get the headers associated with the Request.
+    ///
+    /// The returned `headers` resource is immutable: `set`, `append`, and
+    /// `delete` operations will fail with `header-error.immutable`.
+    ///
+    /// This headers resource is a child: it must be dropped before the parent
+    /// `outgoing-request` is dropped, or its ownership is transferred to
+    /// another component by e.g. `outgoing-handler.handle`.
+    @since(version = 0.2.0)
+    headers: func() -> headers;
+
+    /// Returns the resource corresponding to the outgoing Body for this Response.
+    ///
+    /// Returns success on the first call: the `outgoing-body` resource for
+    /// this `outgoing-response` can be retrieved at most once. Subsequent
+    /// calls will return error.
+    @since(version = 0.2.0)
+    body: func() -> result<outgoing-body>;
+  }
+
+  /// Represents an outgoing HTTP Request or Response's Body.
+  ///
+  /// A body has both its contents - a stream of bytes - and a (possibly
+  /// empty) set of trailers, inducating the full contents of the body
+  /// have been sent. This resource represents the contents as an
+  /// `output-stream` child resource, and the completion of the body (with
+  /// optional trailers) with a static function that consumes the
+  /// `outgoing-body` resource, and ensures that the user of this interface
+  /// may not write to the body contents after the body has been finished.
+  ///
+  /// If the user code drops this resource, as opposed to calling the static
+  /// method `finish`, the implementation should treat the body as incomplete,
+  /// and that an error has occurred. The implementation should propagate this
+  /// error to the HTTP protocol by whatever means it has available,
+  /// including: corrupting the body on the wire, aborting the associated
+  /// Request, or sending a late status code for the Response.
+  @since(version = 0.2.0)
+  resource outgoing-body {
+
+    /// Returns a stream for writing the body contents.
+    ///
+    /// The returned `output-stream` is a child resource: it must be dropped
+    /// before the parent `outgoing-body` resource is dropped (or finished),
+    /// otherwise the `outgoing-body` drop or `finish` will trap.
+    ///
+    /// Returns success on the first call: the `output-stream` resource for
+    /// this `outgoing-body` may be retrieved at most once. Subsequent calls
+    /// will return error.
+    @since(version = 0.2.0)
+    write: func() -> result<output-stream>;
+
+    /// Finalize an outgoing body, optionally providing trailers. This must be
+    /// called to signal that the response is complete. If the `outgoing-body`
+    /// is dropped without calling `outgoing-body.finalize`, the implementation
+    /// should treat the body as corrupted.
+    ///
+    /// Fails if the body's `outgoing-request` or `outgoing-response` was
+    /// constructed with a Content-Length header, and the contents written
+    /// to the body (via `write`) does not match the value given in the
+    /// Content-Length.
+    @since(version = 0.2.0)
+    finish: static func(
+      this: outgoing-body,
+      trailers: option<trailers>
+    ) -> result<_, error-code>;
+  }
+
+  /// Represents a future which may eventually return an incoming HTTP
+  /// Response, or an error.
+  ///
+  /// This resource is returned by the `wasi:http/outgoing-handler` interface to
+  /// provide the HTTP Response corresponding to the sent Request.
+  @since(version = 0.2.0)
+  resource future-incoming-response {
+    /// Returns a pollable which becomes ready when either the Response has
+    /// been received, or an error has occurred. When this pollable is ready,
+    /// the `get` method will return `some`.
+    @since(version = 0.2.0)
+    subscribe: func() -> pollable;
+
+    /// Returns the incoming HTTP Response, or an error, once one is ready.
+    ///
+    /// The outer `option` represents future readiness. Users can wait on this
+    /// `option` to become `some` using the `subscribe` method.
+    ///
+    /// The outer `result` is used to retrieve the response or error at most
+    /// once. It will be success on the first call in which the outer option
+    /// is `some`, and error on subsequent calls.
+    ///
+    /// The inner `result` represents that either the incoming HTTP Response
+    /// status and headers have received successfully, or that an error
+    /// occurred. Errors may also occur while consuming the response body,
+    /// but those will be reported by the `incoming-body` and its
+    /// `output-stream` child.
+    @since(version = 0.2.0)
+    get: func() -> option<result<result<incoming-response, error-code>>>;
+  }
+}

guests/typescript/wit/deps/io/error.wit

@@ -0,0 +1,34 @@
+package wasi:io@0.2.3;
+
+@since(version = 0.2.0)
+interface error {
+    /// A resource which represents some error information.
+    ///
+    /// The only method provided by this resource is `to-debug-string`,
+    /// which provides some human-readable information about the error.
+    ///
+    /// In the `wasi:io` package, this resource is returned through the
+    /// `wasi:io/streams/stream-error` type.
+    ///
+    /// To provide more specific error information, other interfaces may
+    /// offer functions to "downcast" this error into more specific types. For example,
+    /// errors returned from streams derived from filesystem types can be described using
+    /// the filesystem's own error-code type. This is done using the function
+    /// `wasi:filesystem/types/filesystem-error-code`, which takes a `borrow<error>`
+    /// parameter and returns an `option<wasi:filesystem/types/error-code>`.
+    ///
+    /// The set of functions which can "downcast" an `error` into a more
+    /// concrete type is open.
+    @since(version = 0.2.0)
+    resource error {
+        /// Returns a string that is suitable to assist humans in debugging
+        /// this error.
+        ///
+        /// WARNING: The returned string should not be consumed mechanically!
+        /// It may change across platforms, hosts, or other implementation
+        /// details. Parsing this string is a major platform-compatibility
+        /// hazard.
+        @since(version = 0.2.0)
+        to-debug-string: func() -> string;
+    }
+}

guests/typescript/wit/deps/io/poll.wit

@@ -0,0 +1,47 @@
+package wasi:io@0.2.3;
+
+/// A poll API intended to let users wait for I/O events on multiple handles
+/// at once.
+@since(version = 0.2.0)
+interface poll {
+    /// `pollable` represents a single I/O event which may be ready, or not.
+    @since(version = 0.2.0)
+    resource pollable {
+
+      /// Return the readiness of a pollable. This function never blocks.
+      ///
+      /// Returns `true` when the pollable is ready, and `false` otherwise.
+      @since(version = 0.2.0)
+      ready: func() -> bool;
+
+      /// `block` returns immediately if the pollable is ready, and otherwise
+      /// blocks until ready.
+      ///
+      /// This function is equivalent to calling `poll.poll` on a list
+      /// containing only this pollable.
+      @since(version = 0.2.0)
+      block: func();
+    }
+
+    /// Poll for completion on a set of pollables.
+    ///
+    /// This function takes a list of pollables, which identify I/O sources of
+    /// interest, and waits until one or more of the events is ready for I/O.
+    ///
+    /// The result `list<u32>` contains one or more indices of handles in the
+    /// argument list that is ready for I/O.
+    ///
+    /// This function traps if either:
+    /// - the list is empty, or:
+    /// - the list contains more elements than can be indexed with a `u32` value.
+    ///
+    /// A timeout can be implemented by adding a pollable from the
+    /// wasi-clocks API to the list.
+    ///
+    /// This function does not return a `result`; polling in itself does not
+    /// do any I/O so it doesn't fail. If any of the I/O sources identified by
+    /// the pollables has an error, it is indicated by marking the source as
+    /// being ready for I/O.
+    @since(version = 0.2.0)
+    poll: func(in: list<borrow<pollable>>) -> list<u32>;
+}

guests/typescript/wit/deps/io/streams.wit

@@ -0,0 +1,290 @@
+package wasi:io@0.2.3;
+
+/// WASI I/O is an I/O abstraction API which is currently focused on providing
+/// stream types.
+///
+/// In the future, the component model is expected to add built-in stream types;
+/// when it does, they are expected to subsume this API.
+@since(version = 0.2.0)
+interface streams {
+    @since(version = 0.2.0)
+    use error.{error};
+    @since(version = 0.2.0)
+    use poll.{pollable};
+
+    /// An error for input-stream and output-stream operations.
+    @since(version = 0.2.0)
+    variant stream-error {
+        /// The last operation (a write or flush) failed before completion.
+        ///
+        /// More information is available in the `error` payload.
+        ///
+        /// After this, the stream will be closed. All future operations return
+        /// `stream-error::closed`.
+        last-operation-failed(error),
+        /// The stream is closed: no more input will be accepted by the
+        /// stream. A closed output-stream will return this error on all
+        /// future operations.
+        closed
+    }
+
+    /// An input bytestream.
+    ///
+    /// `input-stream`s are *non-blocking* to the extent practical on underlying
+    /// platforms. I/O operations always return promptly; if fewer bytes are
+    /// promptly available than requested, they return the number of bytes promptly
+    /// available, which could even be zero. To wait for data to be available,
+    /// use the `subscribe` function to obtain a `pollable` which can be polled
+    /// for using `wasi:io/poll`.
+    @since(version = 0.2.0)
+    resource input-stream {
+        /// Perform a non-blocking read from the stream.
+        ///
+        /// When the source of a `read` is binary data, the bytes from the source
+        /// are returned verbatim. When the source of a `read` is known to the
+        /// implementation to be text, bytes containing the UTF-8 encoding of the
+        /// text are returned.
+        ///
+        /// This function returns a list of bytes containing the read data,
+        /// when successful. The returned list will contain up to `len` bytes;
+        /// it may return fewer than requested, but not more. The list is
+        /// empty when no bytes are available for reading at this time. The
+        /// pollable given by `subscribe` will be ready when more bytes are
+        /// available.
+        ///
+        /// This function fails with a `stream-error` when the operation
+        /// encounters an error, giving `last-operation-failed`, or when the
+        /// stream is closed, giving `closed`.
+        ///
+        /// When the caller gives a `len` of 0, it represents a request to
+        /// read 0 bytes. If the stream is still open, this call should
+        /// succeed and return an empty list, or otherwise fail with `closed`.
+        ///
+        /// The `len` parameter is a `u64`, which could represent a list of u8 which
+        /// is not possible to allocate in wasm32, or not desirable to allocate as
+        /// as a return value by the callee. The callee may return a list of bytes
+        /// less than `len` in size while more bytes are available for reading.
+        @since(version = 0.2.0)
+        read: func(
+            /// The maximum number of bytes to read
+            len: u64
+        ) -> result<list<u8>, stream-error>;
+
+        /// Read bytes from a stream, after blocking until at least one byte can
+        /// be read. Except for blocking, behavior is identical to `read`.
+        @since(version = 0.2.0)
+        blocking-read: func(
+            /// The maximum number of bytes to read
+            len: u64
+        ) -> result<list<u8>, stream-error>;
+
+        /// Skip bytes from a stream. Returns number of bytes skipped.
+        ///
+        /// Behaves identical to `read`, except instead of returning a list
+        /// of bytes, returns the number of bytes consumed from the stream.
+        @since(version = 0.2.0)
+        skip: func(
+            /// The maximum number of bytes to skip.
+            len: u64,
+        ) -> result<u64, stream-error>;
+
+        /// Skip bytes from a stream, after blocking until at least one byte
+        /// can be skipped. Except for blocking behavior, identical to `skip`.
+        @since(version = 0.2.0)
+        blocking-skip: func(
+            /// The maximum number of bytes to skip.
+            len: u64,
+        ) -> result<u64, stream-error>;
+
+        /// Create a `pollable` which will resolve once either the specified stream
+        /// has bytes available to read or the other end of the stream has been
+        /// closed.
+        /// The created `pollable` is a child resource of the `input-stream`.
+        /// Implementations may trap if the `input-stream` is dropped before
+        /// all derived `pollable`s created with this function are dropped.
+        @since(version = 0.2.0)
+        subscribe: func() -> pollable;
+    }
+
+
+    /// An output bytestream.
+    ///
+    /// `output-stream`s are *non-blocking* to the extent practical on
+    /// underlying platforms. Except where specified otherwise, I/O operations also
+    /// always return promptly, after the number of bytes that can be written
+    /// promptly, which could even be zero. To wait for the stream to be ready to
+    /// accept data, the `subscribe` function to obtain a `pollable` which can be
+    /// polled for using `wasi:io/poll`.
+    ///
+    /// Dropping an `output-stream` while there's still an active write in
+    /// progress may result in the data being lost. Before dropping the stream,
+    /// be sure to fully flush your writes.
+    @since(version = 0.2.0)
+    resource output-stream {
+        /// Check readiness for writing. This function never blocks.
+        ///
+        /// Returns the number of bytes permitted for the next call to `write`,
+        /// or an error. Calling `write` with more bytes than this function has
+        /// permitted will trap.
+        ///
+        /// When this function returns 0 bytes, the `subscribe` pollable will
+        /// become ready when this function will report at least 1 byte, or an
+        /// error.
+        @since(version = 0.2.0)
+        check-write: func() -> result<u64, stream-error>;
+
+        /// Perform a write. This function never blocks.
+        ///
+        /// When the destination of a `write` is binary data, the bytes from
+        /// `contents` are written verbatim. When the destination of a `write` is
+        /// known to the implementation to be text, the bytes of `contents` are
+        /// transcoded from UTF-8 into the encoding of the destination and then
+        /// written.
+        ///
+        /// Precondition: check-write gave permit of Ok(n) and contents has a
+        /// length of less than or equal to n. Otherwise, this function will trap.
+        ///
+        /// returns Err(closed) without writing if the stream has closed since
+        /// the last call to check-write provided a permit.
+        @since(version = 0.2.0)
+        write: func(
+            contents: list<u8>
+        ) -> result<_, stream-error>;
+
+        /// Perform a write of up to 4096 bytes, and then flush the stream. Block
+        /// until all of these operations are complete, or an error occurs.
+        ///
+        /// This is a convenience wrapper around the use of `check-write`,
+        /// `subscribe`, `write`, and `flush`, and is implemented with the
+        /// following pseudo-code:
+        ///
+        /// ```text
+        /// let pollable = this.subscribe();
+        /// while !contents.is_empty() {
+        ///     // Wait for the stream to become writable
+        ///     pollable.block();
+        ///     let Ok(n) = this.check-write(); // eliding error handling
+        ///     let len = min(n, contents.len());
+        ///     let (chunk, rest) = contents.split_at(len);
+        ///     this.write(chunk  );            // eliding error handling
+        ///     contents = rest;
+        /// }
+        /// this.flush();
+        /// // Wait for completion of `flush`
+        /// pollable.block();
+        /// // Check for any errors that arose during `flush`
+        /// let _ = this.check-write();         // eliding error handling
+        /// ```
+        @since(version = 0.2.0)
+        blocking-write-and-flush: func(
+            contents: list<u8>
+        ) -> result<_, stream-error>;
+
+        /// Request to flush buffered output. This function never blocks.
+        ///
+        /// This tells the output-stream that the caller intends any buffered
+        /// output to be flushed. the output which is expected to be flushed
+        /// is all that has been passed to `write` prior to this call.
+        ///
+        /// Upon calling this function, the `output-stream` will not accept any
+        /// writes (`check-write` will return `ok(0)`) until the flush has
+        /// completed. The `subscribe` pollable will become ready when the
+        /// flush has completed and the stream can accept more writes.
+        @since(version = 0.2.0)
+        flush: func() -> result<_, stream-error>;
+
+        /// Request to flush buffered output, and block until flush completes
+        /// and stream is ready for writing again.
+        @since(version = 0.2.0)
+        blocking-flush: func() -> result<_, stream-error>;
+
+        /// Create a `pollable` which will resolve once the output-stream
+        /// is ready for more writing, or an error has occurred. When this
+        /// pollable is ready, `check-write` will return `ok(n)` with n>0, or an
+        /// error.
+        ///
+        /// If the stream is closed, this pollable is always ready immediately.
+        ///
+        /// The created `pollable` is a child resource of the `output-stream`.
+        /// Implementations may trap if the `output-stream` is dropped before
+        /// all derived `pollable`s created with this function are dropped.
+        @since(version = 0.2.0)
+        subscribe: func() -> pollable;
+
+        /// Write zeroes to a stream.
+        ///
+        /// This should be used precisely like `write` with the exact same
+        /// preconditions (must use check-write first), but instead of
+        /// passing a list of bytes, you simply pass the number of zero-bytes
+        /// that should be written.
+        @since(version = 0.2.0)
+        write-zeroes: func(
+            /// The number of zero-bytes to write
+            len: u64
+        ) -> result<_, stream-error>;
+
+        /// Perform a write of up to 4096 zeroes, and then flush the stream.
+        /// Block until all of these operations are complete, or an error
+        /// occurs.
+        ///
+        /// This is a convenience wrapper around the use of `check-write`,
+        /// `subscribe`, `write-zeroes`, and `flush`, and is implemented with
+        /// the following pseudo-code:
+        ///
+        /// ```text
+        /// let pollable = this.subscribe();
+        /// while num_zeroes != 0 {
+        ///     // Wait for the stream to become writable
+        ///     pollable.block();
+        ///     let Ok(n) = this.check-write(); // eliding error handling
+        ///     let len = min(n, num_zeroes);
+        ///     this.write-zeroes(len);         // eliding error handling
+        ///     num_zeroes -= len;
+        /// }
+        /// this.flush();
+        /// // Wait for completion of `flush`
+        /// pollable.block();
+        /// // Check for any errors that arose during `flush`
+        /// let _ = this.check-write();         // eliding error handling
+        /// ```
+        @since(version = 0.2.0)
+        blocking-write-zeroes-and-flush: func(
+            /// The number of zero-bytes to write
+            len: u64
+        ) -> result<_, stream-error>;
+
+        /// Read from one stream and write to another.
+        ///
+        /// The behavior of splice is equivalent to:
+        /// 1. calling `check-write` on the `output-stream`
+        /// 2. calling `read` on the `input-stream` with the smaller of the
+        /// `check-write` permitted length and the `len` provided to `splice`
+        /// 3. calling `write` on the `output-stream` with that read data.
+        ///
+        /// Any error reported by the call to `check-write`, `read`, or
+        /// `write` ends the splice and reports that error.
+        ///
+        /// This function returns the number of bytes transferred; it may be less
+        /// than `len`.
+        @since(version = 0.2.0)
+        splice: func(
+            /// The stream to read from
+            src: borrow<input-stream>,
+            /// The number of bytes to splice
+            len: u64,
+        ) -> result<u64, stream-error>;
+
+        /// Read from one stream and write to another, with blocking.
+        ///
+        /// This is similar to `splice`, except that it blocks until the
+        /// `output-stream` is ready for writing, and the `input-stream`
+        /// is ready for reading, before performing the `splice`.
+        @since(version = 0.2.0)
+        blocking-splice: func(
+            /// The stream to read from
+            src: borrow<input-stream>,
+            /// The number of bytes to splice
+            len: u64,
+        ) -> result<u64, stream-error>;
+    }
+}

guests/typescript/wit/deps/io/world.wit

@@ -0,0 +1,10 @@
+package wasi:io@0.2.3;
+
+@since(version = 0.2.0)
+world imports {
+    @since(version = 0.2.0)
+    import streams;
+
+    @since(version = 0.2.0)
+    import poll;
+}

guests/typescript/wit/deps/keyvalue-0.2.0-draft/atomic.wit

@@ -0,0 +1,22 @@
+/// A keyvalue interface that provides atomic operations.
+///
+/// Atomic operations are single, indivisible operations. When a fault causes an atomic operation to
+/// fail, it will appear to the invoker of the atomic operation that the action either completed
+/// successfully or did nothing at all.
+///
+/// Please note that this interface is bare functions that take a reference to a bucket. This is to
+/// get around the current lack of a way to "extend" a resource with additional methods inside of
+/// wit. Future version of the interface will instead extend these methods on the base `bucket`
+/// resource.
+interface atomics {
+  	use store.{bucket, error};
+
+  	/// Atomically increment the value associated with the key in the store by the given delta. It
+	/// returns the new value.
+	///
+	/// If the key does not exist in the store, it creates a new key-value pair with the value set
+	/// to the given delta.
+	///
+	/// If any other error occurs, it returns an `Err(error)`.
+	increment: func(bucket: borrow<bucket>, key: string, delta: u64) -> result<u64, error>;
+}

guests/typescript/wit/deps/keyvalue-0.2.0-draft/batch.wit

@@ -0,0 +1,63 @@
+/// A keyvalue interface that provides batch operations.
+///
+/// A batch operation is an operation that operates on multiple keys at once.
+///
+/// Batch operations are useful for reducing network round-trip time. For example, if you want to
+/// get the values associated with 100 keys, you can either do 100 get operations or you can do 1
+/// batch get operation. The batch operation is faster because it only needs to make 1 network call
+/// instead of 100.
+///
+/// A batch operation does not guarantee atomicity, meaning that if the batch operation fails, some
+/// of the keys may have been modified and some may not.
+///
+/// This interface does has the same consistency guarantees as the `store` interface, meaning that
+/// you should be able to "read your writes."
+///
+/// Please note that this interface is bare functions that take a reference to a bucket. This is to
+/// get around the current lack of a way to "extend" a resource with additional methods inside of
+/// wit. Future version of the interface will instead extend these methods on the base `bucket`
+/// resource.
+interface batch {
+    use store.{bucket, error};
+
+    /// Get the key-value pairs associated with the keys in the store. It returns a list of
+    /// key-value pairs.
+    ///
+    /// If any of the keys do not exist in the store, it returns a `none` value for that pair in the
+    /// list.
+    ///
+    /// MAY show an out-of-date value if there are concurrent writes to the store.
+    ///
+    /// If any other error occurs, it returns an `Err(error)`.
+    get-many: func(bucket: borrow<bucket>, keys: list<string>) -> result<list<option<tuple<string, list<u8>>>>, error>;
+
+    /// Set the values associated with the keys in the store. If the key already exists in the
+    /// store, it overwrites the value.
+    ///
+    /// Note that the key-value pairs are not guaranteed to be set in the order they are provided.
+    ///
+    /// If any of the keys do not exist in the store, it creates a new key-value pair.
+    ///
+    /// If any other error occurs, it returns an `Err(error)`. When an error occurs, it does not
+    /// rollback the key-value pairs that were already set. Thus, this batch operation does not
+    /// guarantee atomicity, implying that some key-value pairs could be set while others might
+    /// fail.
+    ///
+    /// Other concurrent operations may also be able to see the partial results.
+    set-many: func(bucket: borrow<bucket>, key-values: list<tuple<string, list<u8>>>) -> result<_, error>;
+
+    /// Delete the key-value pairs associated with the keys in the store.
+    ///
+    /// Note that the key-value pairs are not guaranteed to be deleted in the order they are
+    /// provided.
+    ///
+    /// If any of the keys do not exist in the store, it skips the key.
+    ///
+    /// If any other error occurs, it returns an `Err(error)`. When an error occurs, it does not
+    /// rollback the key-value pairs that were already deleted. Thus, this batch operation does not
+    /// guarantee atomicity, implying that some key-value pairs could be deleted while others might
+    /// fail.
+    ///
+    /// Other concurrent operations may also be able to see the partial results.
+    delete-many: func(bucket: borrow<bucket>, keys: list<string>) -> result<_, error>;
+}

guests/typescript/wit/deps/keyvalue-0.2.0-draft/store.wit

@@ -0,0 +1,122 @@
+/// A keyvalue interface that provides eventually consistent key-value operations.
+///
+/// Each of these operations acts on a single key-value pair.
+///
+/// The value in the key-value pair is defined as a `u8` byte array and the intention is that it is
+/// the common denominator for all data types defined by different key-value stores to handle data,
+/// ensuring compatibility between different key-value stores. Note: the clients will be expecting
+/// serialization/deserialization overhead to be handled by the key-value store. The value could be
+/// a serialized object from JSON, HTML or vendor-specific data types like AWS S3 objects.
+///
+/// Data consistency in a key value store refers to the guarantee that once a write operation
+/// completes, all subsequent read operations will return the value that was written.
+///
+/// Any implementation of this interface must have enough consistency to guarantee "reading your
+/// writes." In particular, this means that the client should never get a value that is older than
+/// the one it wrote, but it MAY get a newer value if one was written around the same time. These
+/// guarantees only apply to the same client (which will likely be provided by the host or an
+/// external capability of some kind). In this context a "client" is referring to the caller or
+/// guest that is consuming this interface. Once a write request is committed by a specific client,
+/// all subsequent read requests by the same client will reflect that write or any subsequent
+/// writes. Another client running in a different context may or may not immediately see the result
+/// due to the replication lag. As an example of all of this, if a value at a given key is A, and
+/// the client writes B, then immediately reads, it should get B. If something else writes C in
+/// quick succession, then the client may get C. However, a client running in a separate context may
+/// still see A or B
+interface store {
+    /// The set of errors which may be raised by functions in this package
+    variant error {
+        /// The host does not recognize the store identifier requested.
+        no-such-store,
+
+        /// The requesting component does not have access to the specified store
+        /// (which may or may not exist).
+        access-denied,
+
+        /// Some implementation-specific error has occurred (e.g. I/O)
+        other(string)
+    }
+
+    /// A response to a `list-keys` operation.
+    record key-response {
+        /// The list of keys returned by the query.
+        keys: list<string>,
+        /// The continuation token to use to fetch the next page of keys. If this is `null`, then
+        /// there are no more keys to fetch.
+        cursor: option<u64>
+    }
+
+    /// Get the bucket with the specified identifier.
+    ///
+    /// `identifier` must refer to a bucket provided by the host.
+    ///
+    /// `error::no-such-store` will be raised if the `identifier` is not recognized.
+    open: func(identifier: string) -> result<bucket, error>;
+
+    /// A bucket is a collection of key-value pairs. Each key-value pair is stored as a entry in the
+    /// bucket, and the bucket itself acts as a collection of all these entries.
+    ///
+    /// It is worth noting that the exact terminology for bucket in key-value stores can very
+    /// depending on the specific implementation. For example:
+    ///
+    /// 1. Amazon DynamoDB calls a collection of key-value pairs a table
+    /// 2. Redis has hashes, sets, and sorted sets as different types of collections
+    /// 3. Cassandra calls a collection of key-value pairs a column family
+    /// 4. MongoDB calls a collection of key-value pairs a collection
+    /// 5. Riak calls a collection of key-value pairs a bucket
+    /// 6. Memcached calls a collection of key-value pairs a slab
+    /// 7. Azure Cosmos DB calls a collection of key-value pairs a container
+    ///
+    /// In this interface, we use the term `bucket` to refer to a collection of key-value pairs
+    resource bucket {
+        /// Get the value associated with the specified `key`
+        ///
+        /// The value is returned as an option. If the key-value pair exists in the
+        /// store, it returns `Ok(value)`. If the key does not exist in the
+        /// store, it returns `Ok(none)`.
+        ///
+        /// If any other error occurs, it returns an `Err(error)`.
+        get: func(key: string) -> result<option<list<u8>>, error>;
+
+        /// Set the value associated with the key in the store. If the key already
+        /// exists in the store, it overwrites the value.
+        ///
+        /// If the key does not exist in the store, it creates a new key-value pair.
+        ///
+        /// If any other error occurs, it returns an `Err(error)`.
+        set: func(key: string, value: list<u8>) -> result<_, error>;
+
+        /// Delete the key-value pair associated with the key in the store.
+        ///
+        /// If the key does not exist in the store, it does nothing.
+        ///
+        /// If any other error occurs, it returns an `Err(error)`.
+        delete: func(key: string) -> result<_, error>;
+
+        /// Check if the key exists in the store.
+        ///
+        /// If the key exists in the store, it returns `Ok(true)`. If the key does
+        /// not exist in the store, it returns `Ok(false)`.
+        ///
+        /// If any other error occurs, it returns an `Err(error)`.
+        exists: func(key: string) -> result<bool, error>;
+
+        /// Get all the keys in the store with an optional cursor (for use in pagination). It
+        /// returns a list of keys. Please note that for most KeyValue implementations, this is a
+        /// can be a very expensive operation and so it should be used judiciously. Implementations
+        /// can return any number of keys in a single response, but they should never attempt to
+        /// send more data than is reasonable (i.e. on a small edge device, this may only be a few
+        /// KB, while on a large machine this could be several MB). Any response should also return
+        /// a cursor that can be used to fetch the next page of keys. See the `key-response` record
+        /// for more information.
+        ///
+        /// Note that the keys are not guaranteed to be returned in any particular order.
+        ///
+        /// If the store is empty, it returns an empty list.
+        ///
+        /// MAY show an out-of-date list of keys if there are concurrent writes to the store.
+        ///
+        /// If any error occurs, it returns an `Err(error)`.
+        list-keys: func(cursor: option<u64>) -> result<key-response, error>;
+    }
+}

guests/typescript/wit/deps/keyvalue-0.2.0-draft/watch.wit

@@ -0,0 +1,16 @@
+/// A keyvalue interface that provides watch operations.
+///
+/// This interface is used to provide event-driven mechanisms to handle
+/// keyvalue changes.
+interface watcher {
+	/// A keyvalue interface that provides handle-watch operations.
+	use store.{bucket};
+
+	/// Handle the `set` event for the given bucket and key. It includes a reference to the `bucket`
+	/// that can be used to interact with the store.
+	on-set: func(bucket: bucket, key: string, value: list<u8>);
+
+	/// Handle the `delete` event for the given bucket and key. It includes a reference to the
+	/// `bucket` that can be used to interact with the store.
+	on-delete: func(bucket: bucket, key: string);
+}

guests/typescript/wit/deps/keyvalue-0.2.0-draft/world.wit

@@ -0,0 +1,26 @@
+package wasi:keyvalue@0.2.0-draft;
+
+/// The `wasi:keyvalue/imports` world provides common APIs for interacting with key-value stores.
+/// Components targeting this world will be able to do:
+///
+/// 1. CRUD (create, read, update, delete) operations on key-value stores.
+/// 2. Atomic `increment` and CAS (compare-and-swap) operations.
+/// 3. Batch operations that can reduce the number of round trips to the network.
+world imports {
+	/// The `store` capability allows the component to perform eventually consistent operations on
+	/// the key-value store.
+	import store;
+
+	/// The `atomic` capability allows the component to perform atomic / `increment` and CAS
+	/// (compare-and-swap) operations.
+	import atomics;
+
+	/// The `batch` capability allows the component to perform eventually consistent batch
+	/// operations that can reduce the number of round trips to the network.
+	import batch;
+}
+
+world watch-service {
+	include imports;
+	export watcher;
+}

guests/typescript/wit/deps/random/insecure-seed.wit

@@ -0,0 +1,27 @@
+package wasi:random@0.2.3;
+/// The insecure-seed interface for seeding hash-map DoS resistance.
+///
+/// It is intended to be portable at least between Unix-family platforms and
+/// Windows.
+@since(version = 0.2.0)
+interface insecure-seed {
+    /// Return a 128-bit value that may contain a pseudo-random value.
+    ///
+    /// The returned value is not required to be computed from a CSPRNG, and may
+    /// even be entirely deterministic. Host implementations are encouraged to
+    /// provide pseudo-random values to any program exposed to
+    /// attacker-controlled content, to enable DoS protection built into many
+    /// languages' hash-map implementations.
+    ///
+    /// This function is intended to only be called once, by a source language
+    /// to initialize Denial Of Service (DoS) protection in its hash-map
+    /// implementation.
+    ///
+    /// # Expected future evolution
+    ///
+    /// This will likely be changed to a value import, to prevent it from being
+    /// called multiple times and potentially used for purposes other than DoS
+    /// protection.
+    @since(version = 0.2.0)
+    insecure-seed: func() -> tuple<u64, u64>;
+}

guests/typescript/wit/deps/random/insecure.wit

@@ -0,0 +1,25 @@
+package wasi:random@0.2.3;
+/// The insecure interface for insecure pseudo-random numbers.
+///
+/// It is intended to be portable at least between Unix-family platforms and
+/// Windows.
+@since(version = 0.2.0)
+interface insecure {
+    /// Return `len` insecure pseudo-random bytes.
+    ///
+    /// This function is not cryptographically secure. Do not use it for
+    /// anything related to security.
+    ///
+    /// There are no requirements on the values of the returned bytes, however
+    /// implementations are encouraged to return evenly distributed values with
+    /// a long period.
+    @since(version = 0.2.0)
+    get-insecure-random-bytes: func(len: u64) -> list<u8>;
+
+    /// Return an insecure pseudo-random `u64` value.
+    ///
+    /// This function returns the same type of pseudo-random data as
+    /// `get-insecure-random-bytes`, represented as a `u64`.
+    @since(version = 0.2.0)
+    get-insecure-random-u64: func() -> u64;
+}

guests/typescript/wit/deps/random/random.wit

@@ -0,0 +1,29 @@
+package wasi:random@0.2.3;
+/// WASI Random is a random data API.
+///
+/// It is intended to be portable at least between Unix-family platforms and
+/// Windows.
+@since(version = 0.2.0)
+interface random {
+    /// Return `len` cryptographically-secure random or pseudo-random bytes.
+    ///
+    /// This function must produce data at least as cryptographically secure and
+    /// fast as an adequately seeded cryptographically-secure pseudo-random
+    /// number generator (CSPRNG). It must not block, from the perspective of
+    /// the calling program, under any circumstances, including on the first
+    /// request and on requests for numbers of bytes. The returned data must
+    /// always be unpredictable.
+    ///
+    /// This function must always return fresh data. Deterministic environments
+    /// must omit this function, rather than implementing it with deterministic
+    /// data.
+    @since(version = 0.2.0)
+    get-random-bytes: func(len: u64) -> list<u8>;
+
+    /// Return a cryptographically-secure random or pseudo-random `u64` value.
+    ///
+    /// This function returns the same type of data as `get-random-bytes`,
+    /// represented as a `u64`.
+    @since(version = 0.2.0)
+    get-random-u64: func() -> u64;
+}

guests/typescript/wit/deps/random/world.wit

@@ -0,0 +1,13 @@
+package wasi:random@0.2.3;
+
+@since(version = 0.2.0)
+world imports {
+    @since(version = 0.2.0)
+    import random;
+
+    @since(version = 0.2.0)
+    import insecure;
+
+    @since(version = 0.2.0)
+    import insecure-seed;
+}

guests/typescript/wit/deps/sockets/instance-network.wit

@@ -0,0 +1,11 @@
+
+/// This interface provides a value-export of the default network handle..
+@since(version = 0.2.0)
+interface instance-network {
+    @since(version = 0.2.0)
+    use network.{network};
+
+    /// Get a handle to the default network.
+    @since(version = 0.2.0)
+    instance-network: func() -> network;
+}

guests/typescript/wit/deps/sockets/ip-name-lookup.wit

@@ -0,0 +1,56 @@
+@since(version = 0.2.0)
+interface ip-name-lookup {
+    @since(version = 0.2.0)
+    use wasi:io/poll@0.2.3.{pollable};
+    @since(version = 0.2.0)
+    use network.{network, error-code, ip-address};
+
+    /// Resolve an internet host name to a list of IP addresses.
+    ///
+    /// Unicode domain names are automatically converted to ASCII using IDNA encoding.
+    /// If the input is an IP address string, the address is parsed and returned
+    /// as-is without making any external requests.
+    ///
+    /// See the wasi-socket proposal README.md for a comparison with getaddrinfo.
+    ///
+    /// This function never blocks. It either immediately fails or immediately
+    /// returns successfully with a `resolve-address-stream` that can be used
+    /// to (asynchronously) fetch the results.
+    ///
+    /// # Typical errors
+    /// - `invalid-argument`: `name` is a syntactically invalid domain name or IP address.
+    ///
+    /// # References:
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getaddrinfo.html>
+    /// - <https://man7.org/linux/man-pages/man3/getaddrinfo.3.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/ws2tcpip/nf-ws2tcpip-getaddrinfo>
+    /// - <https://man.freebsd.org/cgi/man.cgi?query=getaddrinfo&sektion=3>
+    @since(version = 0.2.0)
+    resolve-addresses: func(network: borrow<network>, name: string) -> result<resolve-address-stream, error-code>;
+
+    @since(version = 0.2.0)
+    resource resolve-address-stream {
+        /// Returns the next address from the resolver.
+        ///
+        /// This function should be called multiple times. On each call, it will
+        /// return the next address in connection order preference. If all
+        /// addresses have been exhausted, this function returns `none`.
+        ///
+        /// This function never returns IPv4-mapped IPv6 addresses.
+        ///
+        /// # Typical errors
+        /// - `name-unresolvable`:          Name does not exist or has no suitable associated IP addresses. (EAI_NONAME, EAI_NODATA, EAI_ADDRFAMILY)
+        /// - `temporary-resolver-failure`: A temporary failure in name resolution occurred. (EAI_AGAIN)
+        /// - `permanent-resolver-failure`: A permanent failure in name resolution occurred. (EAI_FAIL)
+        /// - `would-block`:                A result is not available yet. (EWOULDBLOCK, EAGAIN)
+        @since(version = 0.2.0)
+        resolve-next-address: func() -> result<option<ip-address>, error-code>;
+
+        /// Create a `pollable` which will resolve once the stream is ready for I/O.
+        ///
+        /// Note: this function is here for WASI 0.2 only.
+        /// It's planned to be removed when `future` is natively supported in Preview3.
+        @since(version = 0.2.0)
+        subscribe: func() -> pollable;
+    }
+}

guests/typescript/wit/deps/sockets/network.wit

@@ -0,0 +1,169 @@
+@since(version = 0.2.0)
+interface network {
+    @unstable(feature = network-error-code)
+    use wasi:io/error@0.2.3.{error};
+
+    /// An opaque resource that represents access to (a subset of) the network.
+    /// This enables context-based security for networking.
+    /// There is no need for this to map 1:1 to a physical network interface.
+    @since(version = 0.2.0)
+    resource network;
+
+    /// Error codes.
+    ///
+    /// In theory, every API can return any error code.
+    /// In practice, API's typically only return the errors documented per API
+    /// combined with a couple of errors that are always possible:
+    /// - `unknown`
+    /// - `access-denied`
+    /// - `not-supported`
+    /// - `out-of-memory`
+    /// - `concurrency-conflict`
+    ///
+    /// See each individual API for what the POSIX equivalents are. They sometimes differ per API.
+    @since(version = 0.2.0)
+    enum error-code {
+        /// Unknown error
+        unknown,
+
+        /// Access denied.
+        ///
+        /// POSIX equivalent: EACCES, EPERM
+        access-denied,
+
+        /// The operation is not supported.
+        ///
+        /// POSIX equivalent: EOPNOTSUPP
+        not-supported,
+
+        /// One of the arguments is invalid.
+        ///
+        /// POSIX equivalent: EINVAL
+        invalid-argument,
+
+        /// Not enough memory to complete the operation.
+        ///
+        /// POSIX equivalent: ENOMEM, ENOBUFS, EAI_MEMORY
+        out-of-memory,
+
+        /// The operation timed out before it could finish completely.
+        timeout,
+
+        /// This operation is incompatible with another asynchronous operation that is already in progress.
+        ///
+        /// POSIX equivalent: EALREADY
+        concurrency-conflict,
+
+        /// Trying to finish an asynchronous operation that:
+        /// - has not been started yet, or:
+        /// - was already finished by a previous `finish-*` call.
+        ///
+        /// Note: this is scheduled to be removed when `future`s are natively supported.
+        not-in-progress,
+
+        /// The operation has been aborted because it could not be completed immediately.
+        ///
+        /// Note: this is scheduled to be removed when `future`s are natively supported.
+        would-block,
+
+
+        /// The operation is not valid in the socket's current state.
+        invalid-state,
+
+        /// A new socket resource could not be created because of a system limit.
+        new-socket-limit,
+
+        /// A bind operation failed because the provided address is not an address that the `network` can bind to.
+        address-not-bindable,
+
+        /// A bind operation failed because the provided address is already in use or because there are no ephemeral ports available.
+        address-in-use,
+
+        /// The remote address is not reachable
+        remote-unreachable,
+
+
+        /// The TCP connection was forcefully rejected
+        connection-refused,
+
+        /// The TCP connection was reset.
+        connection-reset,
+
+        /// A TCP connection was aborted.
+        connection-aborted,
+
+
+        /// The size of a datagram sent to a UDP socket exceeded the maximum
+        /// supported size.
+        datagram-too-large,
+
+
+        /// Name does not exist or has no suitable associated IP addresses.
+        name-unresolvable,
+
+        /// A temporary failure in name resolution occurred.
+        temporary-resolver-failure,
+
+        /// A permanent failure in name resolution occurred.
+        permanent-resolver-failure,
+    }
+
+    /// Attempts to extract a network-related `error-code` from the stream
+    /// `error` provided.
+    ///
+    /// Stream operations which return `stream-error::last-operation-failed`
+    /// have a payload with more information about the operation that failed.
+    /// This payload can be passed through to this function to see if there's
+    /// network-related information about the error to return.
+    ///
+    /// Note that this function is fallible because not all stream-related
+    /// errors are network-related errors.
+    @unstable(feature = network-error-code)
+    network-error-code: func(err: borrow<error>) -> option<error-code>;
+
+    @since(version = 0.2.0)
+    enum ip-address-family {
+        /// Similar to `AF_INET` in POSIX.
+        ipv4,
+
+        /// Similar to `AF_INET6` in POSIX.
+        ipv6,
+    }
+
+    @since(version = 0.2.0)
+    type ipv4-address = tuple<u8, u8, u8, u8>;
+    @since(version = 0.2.0)
+    type ipv6-address = tuple<u16, u16, u16, u16, u16, u16, u16, u16>;
+
+    @since(version = 0.2.0)
+    variant ip-address {
+        ipv4(ipv4-address),
+        ipv6(ipv6-address),
+    }
+
+    @since(version = 0.2.0)
+    record ipv4-socket-address {
+        /// sin_port
+        port: u16,
+        /// sin_addr
+        address: ipv4-address,
+    }
+
+    @since(version = 0.2.0)
+    record ipv6-socket-address {
+        /// sin6_port
+        port: u16,
+        /// sin6_flowinfo
+        flow-info: u32,
+        /// sin6_addr
+        address: ipv6-address,
+        /// sin6_scope_id
+        scope-id: u32,
+    }
+
+    @since(version = 0.2.0)
+    variant ip-socket-address {
+        ipv4(ipv4-socket-address),
+        ipv6(ipv6-socket-address),
+    }
+}

guests/typescript/wit/deps/sockets/tcp-create-socket.wit

@@ -0,0 +1,30 @@
+@since(version = 0.2.0)
+interface tcp-create-socket {
+    @since(version = 0.2.0)
+    use network.{network, error-code, ip-address-family};
+    @since(version = 0.2.0)
+    use tcp.{tcp-socket};
+
+    /// Create a new TCP socket.
+    ///
+    /// Similar to `socket(AF_INET or AF_INET6, SOCK_STREAM, IPPROTO_TCP)` in POSIX.
+    /// On IPv6 sockets, IPV6_V6ONLY is enabled by default and can't be configured otherwise.
+    ///
+    /// This function does not require a network capability handle. This is considered to be safe because
+    /// at time of creation, the socket is not bound to any `network` yet. Up to the moment `bind`/`connect`
+    /// is called, the socket is effectively an in-memory configuration object, unable to communicate with the outside world.
+    ///
+    /// All sockets are non-blocking. Use the wasi-poll interface to block on asynchronous operations.
+    ///
+    /// # Typical errors
+    /// - `not-supported`:     The specified `address-family` is not supported. (EAFNOSUPPORT)
+    /// - `new-socket-limit`:  The new socket resource could not be created because of a system limit. (EMFILE, ENFILE)
+    ///
+    /// # References
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/socket.html>
+    /// - <https://man7.org/linux/man-pages/man2/socket.2.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasocketw>
+    /// - <https://man.freebsd.org/cgi/man.cgi?query=socket&sektion=2>
+    @since(version = 0.2.0)
+    create-tcp-socket: func(address-family: ip-address-family) -> result<tcp-socket, error-code>;
+}