spacetimedb 2.3.0 → 2.4.1

package/dist/server/index.mjs

@@ -1,6 +1,7 @@
 import * as _syscalls2_0 from 'spacetime:sys@2.0';
 import { moduleHooks } from 'spacetime:sys@2.0';
-import { headersToList, Headers } from 'headers-polyfill';
+import { Headers, headersToList } from 'headers-polyfill';
+export { Headers } from 'headers-polyfill';
 import * as _syscalls2_1 from 'spacetime:sys@2.1';
 
 typeof globalThis!=="undefined"&&((globalThis.global=globalThis.global||globalThis),(globalThis.window=globalThis.window||globalThis));
@@ -4606,6 +4607,12 @@ var Lifecycle = t.enum("Lifecycle", {
   OnConnect: t.unit(),
   OnDisconnect: t.unit()
 });
+var MethodOrAny = t.enum("MethodOrAny", {
+  Any: t.unit(),
+  get Method() {
+    return HttpMethod;
+  }
+});
 var MiscModuleExport = t.enum("MiscModuleExport", {
   get TypeAlias() {
     return TypeAlias;
@@ -4663,6 +4670,16 @@ var RawConstraintDefV9 = t.object("RawConstraintDefV9", {
     return RawConstraintDataV9;
   }
 });
+var RawHttpHandlerDefV10 = t.object("RawHttpHandlerDefV10", {
+  sourceName: t.string()
+});
+var RawHttpRouteDefV10 = t.object("RawHttpRouteDefV10", {
+  handlerFunction: t.string(),
+  get method() {
+    return MethodOrAny;
+  },
+  path: t.string()
+});
 var RawIndexAlgorithm = t.enum("RawIndexAlgorithm", {
   BTree: t.array(t.u16()),
   Hash: t.array(t.u16()),
@@ -4759,6 +4776,15 @@ var RawModuleDefV10Section = t.enum("RawModuleDefV10Section", {
   },
   get ExplicitNames() {
     return ExplicitNames;
+  },
+  get HttpHandlers() {
+    return t.array(RawHttpHandlerDefV10);
+  },
+  get HttpRoutes() {
+    return t.array(RawHttpRouteDefV10);
+  },
+  get ViewPrimaryKeys() {
+    return t.array(RawViewPrimaryKeyDefV10);
   }
 });
 var RawModuleDefV8 = t.object("RawModuleDefV8", {
@@ -4996,6 +5022,10 @@ var RawViewDefV9 = t.object("RawViewDefV9", {
     return AlgebraicType2;
   }
 });
+var RawViewPrimaryKeyDefV10 = t.object("RawViewPrimaryKeyDefV10", {
+  viewSourceName: t.string(),
+  columns: t.array(t.string())
+});
 var ReducerDef = t.object("ReducerDef", {
   name: t.string(),
   get args() {
@@ -5106,7 +5136,10 @@ var ModuleContext = class {
     schedules: [],
     procedures: [],
     views: [],
+    viewPrimaryKeys: [],
     lifeCycleReducers: [],
+    httpHandlers: [],
+    httpRoutes: [],
     caseConversionPolicy: { tag: "SnakeCase" },
     explicitNames: {
       entries: []
@@ -5127,6 +5160,12 @@ var ModuleContext = class {
     push(module.reducers && { tag: "Reducers", value: module.reducers });
     push(module.procedures && { tag: "Procedures", value: module.procedures });
     push(module.views && { tag: "Views", value: module.views });
+    push(
+      module.viewPrimaryKeys && {
+        tag: "ViewPrimaryKeys",
+        value: module.viewPrimaryKeys
+      }
+    );
     push(module.schedules && { tag: "Schedules", value: module.schedules });
     push(
       module.lifeCycleReducers && {
@@ -5134,6 +5173,18 @@ var ModuleContext = class {
         value: module.lifeCycleReducers
       }
     );
+    push(
+      module.httpHandlers && {
+        tag: "HttpHandlers",
+        value: module.httpHandlers
+      }
+    );
+    push(
+      module.httpRoutes && {
+        tag: "HttpRoutes",
+        value: module.httpRoutes
+      }
+    );
     push(
       module.rowLevelSecurity && {
         tag: "RowLevelSecurity",
@@ -5263,6 +5314,396 @@ function splitName(name) {
   const scope = name.split(".");
   return { sourceName: scope.pop(), scope };
 }
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder("utf-8");
+function deserializeMethod(method) {
+  switch (method.tag) {
+    case "Get":
+      return "GET";
+    case "Head":
+      return "HEAD";
+    case "Post":
+      return "POST";
+    case "Put":
+      return "PUT";
+    case "Delete":
+      return "DELETE";
+    case "Connect":
+      return "CONNECT";
+    case "Options":
+      return "OPTIONS";
+    case "Trace":
+      return "TRACE";
+    case "Patch":
+      return "PATCH";
+    case "Extension":
+      return method.value;
+  }
+}
+var methods = /* @__PURE__ */ new Map([
+  ["GET", { tag: "Get" }],
+  ["HEAD", { tag: "Head" }],
+  ["POST", { tag: "Post" }],
+  ["PUT", { tag: "Put" }],
+  ["DELETE", { tag: "Delete" }],
+  ["CONNECT", { tag: "Connect" }],
+  ["OPTIONS", { tag: "Options" }],
+  ["TRACE", { tag: "Trace" }],
+  ["PATCH", { tag: "Patch" }]
+]);
+function serializeMethod(method) {
+  return methods.get(method?.toUpperCase() ?? "GET") ?? {
+    tag: "Extension",
+    value: method
+  };
+}
+function serializeHeaders(headers) {
+  return {
+    entries: headersToList(headers).flatMap(([k, v]) => Array.isArray(v) ? v.map((v2) => [k, v2]) : [[k, v]]).map(([name, value]) => ({ name, value: textEncoder.encode(value) }))
+  };
+}
+function deserializeHeaders(headers) {
+  return new Headers(
+    headers.entries.map(({ name, value }) => [
+      name,
+      textDecoder.decode(value)
+    ])
+  );
+}
+var makeResponse = Symbol("makeResponse");
+var SyncResponse = class _SyncResponse {
+  #body;
+  #inner;
+  constructor(body, init) {
+    if (body == null) {
+      this.#body = null;
+    } else if (typeof body === "string") {
+      this.#body = body;
+    } else {
+      this.#body = new Uint8Array(body).buffer;
+    }
+    this.#inner = {
+      headers: new Headers(init?.headers),
+      status: init?.status ?? 200,
+      statusText: init?.statusText ?? "",
+      type: "default",
+      url: null,
+      aborted: false,
+      version: init?.version ?? { tag: "Http11" }
+    };
+  }
+  static [makeResponse](body, inner) {
+    const me = new _SyncResponse(body);
+    me.#inner = inner;
+    return me;
+  }
+  get headers() {
+    return this.#inner.headers;
+  }
+  get status() {
+    return this.#inner.status;
+  }
+  get statusText() {
+    return this.#inner.statusText;
+  }
+  get ok() {
+    return 200 <= this.#inner.status && this.#inner.status <= 299;
+  }
+  get url() {
+    return this.#inner.url ?? "";
+  }
+  get type() {
+    return this.#inner.type;
+  }
+  get version() {
+    return this.#inner.version;
+  }
+  arrayBuffer() {
+    return this.bytes().buffer;
+  }
+  bytes() {
+    if (this.#body == null) {
+      return new Uint8Array();
+    } else if (typeof this.#body === "string") {
+      return textEncoder.encode(this.#body);
+    } else {
+      return new Uint8Array(this.#body);
+    }
+  }
+  json() {
+    return JSON.parse(this.text());
+  }
+  text() {
+    if (this.#body == null) {
+      return "";
+    } else if (typeof this.#body === "string") {
+      return this.#body;
+    } else {
+      return textDecoder.decode(this.#body);
+    }
+  }
+};
+
+// src/server/http_handlers.ts
+var httpHandlerFn = Symbol("SpacetimeDB.httpHandlerFn");
+var ACCEPTABLE_ROUTE_PATH_CHARS_HUMAN_DESCRIPTION = "ASCII lowercase letters, digits and `-_~/`";
+var makeRequest = Symbol("makeRequest");
+function coerceRequestBody(body) {
+  if (body == null) {
+    return null;
+  }
+  if (typeof body === "string") {
+    return body;
+  }
+  return new Uint8Array(body);
+}
+function requestBodyToBytes(body) {
+  if (body == null) {
+    return new Uint8Array();
+  }
+  if (typeof body === "string") {
+    return textEncoder.encode(body);
+  }
+  return body;
+}
+function requestBodyToText(body) {
+  if (body == null) {
+    return "";
+  }
+  if (typeof body === "string") {
+    return body;
+  }
+  return textDecoder.decode(body);
+}
+function characterIsAcceptableForRoutePath(c) {
+  return c >= "a" && c <= "z" || c >= "0" && c <= "9" || c === "-" || c === "_" || c === "~" || c === "/";
+}
+function assertValidPath(path) {
+  if (path !== "" && !path.startsWith("/")) {
+    throw new TypeError(`Route paths must start with \`/\`: ${path}`);
+  }
+  if (![...path].every(characterIsAcceptableForRoutePath)) {
+    throw new TypeError(
+      `Route paths may contain only ${ACCEPTABLE_ROUTE_PATH_CHARS_HUMAN_DESCRIPTION}: ${path}`
+    );
+  }
+}
+function routesOverlap(a, b) {
+  const methodsMatch = (left, right) => {
+    if (left.tag !== right.tag) {
+      return false;
+    }
+    if (left.tag === "Extension" && right.tag === "Extension") {
+      return left.value === right.value;
+    }
+    return true;
+  };
+  return a.path === b.path && (a.method.tag === "Any" || b.method.tag === "Any" || a.method.tag === "Method" && b.method.tag === "Method" && methodsMatch(a.method.value, b.method.value));
+}
+function joinPaths(prefix, suffix) {
+  if (prefix === "/") {
+    return suffix;
+  }
+  if (suffix === "/") {
+    return prefix;
+  }
+  let prefixEnd = prefix.length;
+  while (prefixEnd > 0 && prefix[prefixEnd - 1] === "/") {
+    prefixEnd--;
+  }
+  let suffixStart = 0;
+  while (suffixStart < suffix.length && suffix[suffixStart] === "/") {
+    suffixStart++;
+  }
+  const joinedPrefix = prefix.slice(0, prefixEnd);
+  const joinedSuffix = suffix.slice(suffixStart);
+  return `${joinedPrefix}/${joinedSuffix}`;
+}
+var Request = class _Request {
+  #body;
+  #inner;
+  constructor(url, init = {}) {
+    this.#body = coerceRequestBody(init.body);
+    this.#inner = {
+      headers: new Headers(init.headers),
+      method: init.method ?? "GET",
+      uri: "" + url,
+      version: init.version ?? { tag: "Http11" }
+    };
+  }
+  static [makeRequest](body, inner) {
+    const me = new _Request(inner.uri);
+    me.#body = coerceRequestBody(body);
+    me.#inner = inner;
+    return me;
+  }
+  get headers() {
+    return this.#inner.headers;
+  }
+  get method() {
+    return this.#inner.method;
+  }
+  get uri() {
+    return this.#inner.uri;
+  }
+  get url() {
+    return this.#inner.uri;
+  }
+  get version() {
+    return this.#inner.version;
+  }
+  arrayBuffer() {
+    return this.bytes().buffer;
+  }
+  bytes() {
+    return requestBodyToBytes(this.#body);
+  }
+  json() {
+    return JSON.parse(this.text());
+  }
+  text() {
+    return requestBodyToText(this.#body);
+  }
+};
+var exportedHttpHandlerObjects = /* @__PURE__ */ new WeakSet();
+var Router = class _Router {
+  #routes;
+  constructor(routes = []) {
+    this.#routes = routes;
+  }
+  get(path, handler) {
+    return this.addRoute(
+      { tag: "Method", value: { tag: "Get" } },
+      path,
+      handler
+    );
+  }
+  head(path, handler) {
+    return this.addRoute(
+      { tag: "Method", value: { tag: "Head" } },
+      path,
+      handler
+    );
+  }
+  options(path, handler) {
+    return this.addRoute(
+      { tag: "Method", value: { tag: "Options" } },
+      path,
+      handler
+    );
+  }
+  put(path, handler) {
+    return this.addRoute(
+      { tag: "Method", value: { tag: "Put" } },
+      path,
+      handler
+    );
+  }
+  delete(path, handler) {
+    return this.addRoute(
+      { tag: "Method", value: { tag: "Delete" } },
+      path,
+      handler
+    );
+  }
+  post(path, handler) {
+    return this.addRoute(
+      { tag: "Method", value: { tag: "Post" } },
+      path,
+      handler
+    );
+  }
+  patch(path, handler) {
+    return this.addRoute(
+      { tag: "Method", value: { tag: "Patch" } },
+      path,
+      handler
+    );
+  }
+  any(path, handler) {
+    return this.addRoute({ tag: "Any" }, path, handler);
+  }
+  nest(path, subRouter) {
+    assertValidPath(path);
+    if (this.#routes.some((route) => route.path.startsWith(path))) {
+      throw new TypeError(
+        `Cannot nest router at \`${path}\`; existing routes overlap with nested path`
+      );
+    }
+    let merged = new _Router(this.#routes);
+    for (const route of subRouter.#routes) {
+      merged = merged.addRoute(
+        route.method,
+        joinPaths(path, route.path),
+        route.handler
+      );
+    }
+    return merged;
+  }
+  merge(otherRouter) {
+    let merged = new _Router(this.#routes);
+    for (const route of otherRouter.#routes) {
+      merged = merged.addRoute(route.method, route.path, route.handler);
+    }
+    return merged;
+  }
+  intoRoutes() {
+    return this.#routes.slice();
+  }
+  addRoute(method, path, handler) {
+    assertValidPath(path);
+    const candidate = { method, path, handler };
+    if (this.#routes.some((route) => routesOverlap(route, candidate))) {
+      throw new TypeError(`Route conflict for \`${path}\``);
+    }
+    return new _Router([...this.#routes, candidate]);
+  }
+};
+function makeHttpHandlerExport(ctx, opts, fn) {
+  const handlerExport = {
+    [httpHandlerFn]: fn,
+    [exportContext]: ctx,
+    [registerExport](ctx2, exportName) {
+      if (exportedHttpHandlerObjects.has(handlerExport)) {
+        throw new TypeError(
+          `HTTP handler '${exportName}' was exported more than once`
+        );
+      }
+      exportedHttpHandlerObjects.add(handlerExport);
+      registerHttpHandler(ctx2, exportName, fn, opts);
+      ctx2.httpHandlerExports.set(
+        handlerExport,
+        exportName
+      );
+    }
+  };
+  return handlerExport;
+}
+function makeHttpRouterExport(ctx, router) {
+  return {
+    [exportContext]: ctx,
+    [registerExport](ctx2) {
+      ctx2.pendingHttpRoutes.push(...router.intoRoutes());
+    }
+  };
+}
+function registerHttpHandler(ctx, exportName, fn, opts) {
+  ctx.defineHttpHandler(exportName);
+  ctx.moduleDef.httpHandlers.push({ sourceName: exportName });
+  if (opts?.name != null) {
+    ctx.moduleDef.explicitNames.entries.push({
+      tag: "Function",
+      value: {
+        sourceName: exportName,
+        canonicalName: opts.name
+      }
+    });
+  }
+  if (!fn.name) {
+    Object.defineProperty(fn, "name", { value: exportName, writable: false });
+  }
+  ctx.httpHandlers.push(fn);
+}
 
 // src/server/http_internal.ts
 var import_statuses = __toESM(require_statuses());
@@ -5894,6 +6335,7 @@ function makeAnonViewExport(ctx, opts, params, ret, fn) {
   return viewExport;
 }
 function registerView(ctx, opts, exportName, anon, params, ret, fn) {
+  ctx.defineFunction(exportName);
   const paramsBuilder = new RowBuilder(params, toPascalCase(exportName));
   let returnType = ctx.registerTypesRecursively(ret).algebraicType;
   const { typespace } = ctx;
@@ -5908,6 +6350,18 @@ function registerView(ctx, opts, exportName, anon, params, ret, fn) {
     params: paramType,
     returnType
   });
+  const primaryKeyColumns = viewPrimaryKeyColumns(ret);
+  if (primaryKeyColumns.length > 1) {
+    throw new TypeError(
+      `View '${exportName}' can have at most one primaryKey() column on its returned row type; found ${primaryKeyColumns.join(", ")}`
+    );
+  }
+  if (primaryKeyColumns.length === 1) {
+    ctx.moduleDef.viewPrimaryKeys.push({
+      viewSourceName: exportName,
+      columns: primaryKeyColumns
+    });
+  }
   if (opts.name != null) {
     ctx.moduleDef.explicitNames.entries.push({
       tag: "Function",
@@ -5934,6 +6388,24 @@ function registerView(ctx, opts, exportName, anon, params, ret, fn) {
     returnTypeBaseSize: bsatnBaseSize(typespace, returnType)
   });
 }
+function viewPrimaryKeyColumns(ret) {
+  const row = viewReturnRow(ret);
+  if (row == null) {
+    return [];
+  }
+  return Object.entries(row.row).filter(
+    (entry) => entry[1].columnMetadata.isPrimaryKey === true
+  ).map(([name]) => name);
+}
+function viewReturnRow(ret) {
+  if (ret instanceof ArrayBuilder && ret.element instanceof RowBuilder) {
+    return ret.element;
+  }
+  if (ret instanceof OptionBuilder && ret.value instanceof RowBuilder) {
+    return ret.value;
+  }
+  return void 0;
+}
 
 // src/lib/errors.ts
 var SenderError = class extends Error {
@@ -6303,6 +6775,24 @@ function makeRandom(seed) {
 // src/server/runtime.ts
 var { freeze } = Object;
 var sys = { ..._syscalls2_0, ..._syscalls2_1 };
+function requestFromWire(request, body) {
+  return Request[makeRequest](body, {
+    headers: deserializeHeaders(request.headers),
+    method: deserializeMethod(request.method),
+    uri: request.uri,
+    version: request.version
+  });
+}
+function responseIntoWire(response) {
+  return [
+    {
+      headers: serializeHeaders(response.headers),
+      version: response.version,
+      code: response.status
+    },
+    response.bytes()
+  ];
+}
 function parseJsonObject(json) {
   let value;
   try {
@@ -6467,6 +6957,31 @@ var ReducerCtxImpl = class ReducerCtx {
 var callUserFunction = function __spacetimedb_end_short_backtrace(fn, ...args) {
   return fn(...args);
 };
+function runWithTx(makeCtx, body) {
+  const run = () => {
+    const timestamp = sys.procedure_start_mut_tx();
+    try {
+      return body(makeCtx(new Timestamp(timestamp)));
+    } catch (e) {
+      sys.procedure_abort_mut_tx();
+      throw e;
+    }
+  };
+  let res = run();
+  try {
+    sys.procedure_commit_mut_tx();
+    return res;
+  } catch {
+  }
+  console.warn("committing anonymous transaction failed");
+  res = run();
+  try {
+    sys.procedure_commit_mut_tx();
+    return res;
+  } catch (e) {
+    throw new Error("transaction retry failed again", { cause: e });
+  }
+}
 var makeHooks = (schema2) => new ModuleHooksImpl(schema2);
 var ModuleHooksImpl = class {
   #schema;
@@ -6583,9 +7098,61 @@ var ModuleHooksImpl = class {
       () => this.#dbView
     );
   }
+  __call_http_handler__(id, timestamp, request, body) {
+    const moduleCtx = this.#schema;
+    const handler = moduleCtx.httpHandlers[id];
+    const ctx = new HandlerContextImpl(
+      new Timestamp(timestamp),
+      () => this.#dbView
+    );
+    const requestMetadata = HttpRequest.deserialize(new BinaryReader(request));
+    const response = callUserFunction(
+      handler,
+      ctx,
+      requestFromWire(requestMetadata, body)
+    );
+    const [responseMetadata, responseBody] = responseIntoWire(response);
+    const responseBuf = new BinaryWriter(
+      bsatnBaseSize(moduleCtx.typespace, HttpResponse.algebraicType)
+    );
+    HttpResponse.serialize(responseBuf, responseMetadata);
+    return [responseBuf.getBuffer(), responseBody];
+  }
 };
 var BINARY_WRITER = new BinaryWriter(0);
 var BINARY_READER = new BinaryReader(new Uint8Array());
+var HandlerContextImpl = class {
+  constructor(timestamp, dbView) {
+    this.timestamp = timestamp;
+    this.#dbView = dbView;
+  }
+  #identity;
+  #uuidCounter;
+  #random;
+  #dbView;
+  http = httpClient;
+  get identity() {
+    return this.#identity ??= new Identity(sys.identity());
+  }
+  get random() {
+    return this.#random ??= makeRandom(this.timestamp);
+  }
+  withTx(body) {
+    return runWithTx(
+      (timestamp) => new ReducerCtxImpl(Identity.zero(), timestamp, null, this.#dbView()),
+      body
+    );
+  }
+  newUuidV4() {
+    const bytes = this.random.fill(new Uint8Array(16));
+    return Uuid.fromRandomBytesV4(bytes);
+  }
+  newUuidV7() {
+    const bytes = this.random.fill(new Uint8Array(4));
+    const counter = this.#uuidCounter ??= { value: 0 };
+    return Uuid.fromCounterV7(counter, this.timestamp, bytes);
+  }
+};
 function makeTableView(typespace, table2) {
   const table_id = sys.table_id_from_name(table2.sourceName);
   const rowType = typespace.types[table2.productTypeRef];
@@ -7034,109 +7601,10 @@ var IteratorHandle = class _IteratorHandle {
 
 // src/server/http_internal.ts
 var { freeze: freeze2 } = Object;
-var textEncoder = new TextEncoder();
-var textDecoder = new TextDecoder(
-  "utf-8"
-  /* { fatal: true } */
-);
-function deserializeHeaders(headers) {
-  return new Headers(
-    headers.entries.map(({ name, value }) => [
-      name,
-      textDecoder.decode(value)
-    ])
-  );
-}
-var makeResponse = Symbol("makeResponse");
-var SyncResponse = class _SyncResponse {
-  #body;
-  #inner;
-  constructor(body, init) {
-    if (body == null) {
-      this.#body = null;
-    } else if (typeof body === "string") {
-      this.#body = body;
-    } else {
-      this.#body = new Uint8Array(body).buffer;
-    }
-    this.#inner = {
-      headers: new Headers(init?.headers),
-      status: init?.status ?? 200,
-      statusText: init?.statusText ?? "",
-      type: "default",
-      url: null,
-      aborted: false
-    };
-  }
-  static [makeResponse](body, inner) {
-    const me = new _SyncResponse(body);
-    me.#inner = inner;
-    return me;
-  }
-  get headers() {
-    return this.#inner.headers;
-  }
-  get status() {
-    return this.#inner.status;
-  }
-  get statusText() {
-    return this.#inner.statusText;
-  }
-  get ok() {
-    return 200 <= this.#inner.status && this.#inner.status <= 299;
-  }
-  get url() {
-    return this.#inner.url ?? "";
-  }
-  get type() {
-    return this.#inner.type;
-  }
-  arrayBuffer() {
-    return this.bytes().buffer;
-  }
-  bytes() {
-    if (this.#body == null) {
-      return new Uint8Array();
-    } else if (typeof this.#body === "string") {
-      return textEncoder.encode(this.#body);
-    } else {
-      return new Uint8Array(this.#body);
-    }
-  }
-  json() {
-    return JSON.parse(this.text());
-  }
-  text() {
-    if (this.#body == null) {
-      return "";
-    } else if (typeof this.#body === "string") {
-      return this.#body;
-    } else {
-      return textDecoder.decode(this.#body);
-    }
-  }
-};
 var requestBaseSize = bsatnBaseSize({ types: [] }, HttpRequest.algebraicType);
-var methods = /* @__PURE__ */ new Map([
-  ["GET", { tag: "Get" }],
-  ["HEAD", { tag: "Head" }],
-  ["POST", { tag: "Post" }],
-  ["PUT", { tag: "Put" }],
-  ["DELETE", { tag: "Delete" }],
-  ["CONNECT", { tag: "Connect" }],
-  ["OPTIONS", { tag: "Options" }],
-  ["TRACE", { tag: "Trace" }],
-  ["PATCH", { tag: "Patch" }]
-]);
 function fetch(url, init = {}) {
-  const method = methods.get(init.method?.toUpperCase() ?? "GET") ?? {
-    tag: "Extension",
-    value: init.method
-  };
-  const headers = {
-    // anys because the typings are wonky - see comment in SyncResponse.constructor
-    entries: headersToList(new Headers(init.headers)).flatMap(([k, v]) => Array.isArray(v) ? v.map((v2) => [k, v2]) : [[k, v]]).map(([name, value]) => ({ name, value: textEncoder.encode(value) }))
-  };
+  const method = serializeMethod(init.method);
+  const headers = serializeHeaders(new Headers(init.headers));
   const uri = "" + url;
   const request = freeze2({
     method,
@@ -7159,7 +7627,8 @@ function fetch(url, init = {}) {
     status: response.code,
     statusText: (0, import_statuses.default)(response.code),
     headers: deserializeHeaders(response.headers),
-    aborted: false
+    aborted: false,
+    version: response.version
   });
 }
 freeze2(fetch);
@@ -7244,35 +7713,15 @@ var ProcedureCtxImpl = class ProcedureCtx {
     return httpClient;
   }
   withTx(body) {
-    const run = () => {
-      const timestamp = sys.procedure_start_mut_tx();
-      try {
-        const ctx = new TransactionCtxImpl(
-          this.sender,
-          new Timestamp(timestamp),
-          this.connectionId,
-          this.#dbView()
-        );
-        return body(ctx);
-      } catch (e) {
-        sys.procedure_abort_mut_tx();
-        throw e;
-      }
-    };
-    let res = run();
-    try {
-      sys.procedure_commit_mut_tx();
-      return res;
-    } catch {
-    }
-    console.warn("committing anonymous transaction failed");
-    res = run();
-    try {
-      sys.procedure_commit_mut_tx();
-      return res;
-    } catch (e) {
-      throw new Error("transaction retry failed again", { cause: e });
-    }
+    return runWithTx(
+      (timestamp) => new TransactionCtxImpl(
+        this.sender,
+        timestamp,
+        this.connectionId,
+        this.#dbView()
+      ),
+      body
+    );
   }
   newUuidV4() {
     const bytes = this.random.fill(new Uint8Array(16));
@@ -7343,16 +7792,20 @@ function registerReducer(ctx, exportName, params, fn, opts, lifecycle) {
 var SchemaInner = class extends ModuleContext {
   schemaType;
   existingFunctions = /* @__PURE__ */ new Set();
+  existingHttpHandlers = /* @__PURE__ */ new Set();
   reducers = [];
   procedures = [];
   views = [];
   anonViews = [];
+  httpHandlers = [];
   /**
    * Maps ReducerExport objects to the name of the reducer.
    * Used for resolving the reducers of scheduled tables.
    */
   functionExports = /* @__PURE__ */ new Map();
+  httpHandlerExports = /* @__PURE__ */ new Map();
   pendingSchedules = [];
+  pendingHttpRoutes = [];
   constructor(getSchemaType) {
     super();
     this.schemaType = getSchemaType(this);
@@ -7360,11 +7813,19 @@ var SchemaInner = class extends ModuleContext {
   defineFunction(name) {
     if (this.existingFunctions.has(name)) {
       throw new TypeError(
-        `There is already a reducer or procedure with the name '${name}'`
+        `There is already a reducer, procedure, or view with the name '${name}'`
       );
     }
     this.existingFunctions.add(name);
   }
+  defineHttpHandler(name) {
+    if (this.existingHttpHandlers.has(name)) {
+      throw new TypeError(
+        `There is already an HTTP handler with the name '${name}'`
+      );
+    }
+    this.existingHttpHandlers.add(name);
+  }
   resolveSchedules() {
     for (const { reducer, scheduleAtCol, tableName } of this.pendingSchedules) {
       const functionName = this.functionExports.get(reducer());
@@ -7380,6 +7841,21 @@ var SchemaInner = class extends ModuleContext {
       });
     }
   }
+  resolveHttpRoutes() {
+    for (const route of this.pendingHttpRoutes) {
+      const handlerFunction = this.httpHandlerExports.get(route.handler);
+      if (handlerFunction === void 0) {
+        throw new TypeError(
+          `HTTP route for path '${route.path}' refers to a handler that was not exported.`
+        );
+      }
+      this.moduleDef.httpRoutes.push({
+        handlerFunction,
+        method: route.method,
+        path: route.path
+      });
+    }
+  }
 };
 var Schema = class {
   #ctx;
@@ -7399,6 +7875,7 @@ var Schema = class {
       moduleExport[registerExport](registeredSchema, name);
     }
     registeredSchema.resolveSchedules();
+    registeredSchema.resolveHttpRoutes();
     return makeHooks(registeredSchema);
   }
   get schemaType() {
@@ -7465,7 +7942,7 @@ var Schema = class {
     }
     return makeReducerExport(this.#ctx, opts, {}, fn, Lifecycle.OnDisconnect);
   }
-  view(opts, ret, fn) {
+  view(opts, ret, fn, ..._) {
     return makeViewExport(this.#ctx, opts, {}, ret, fn);
   }
   // TODO: re-enable once parameterized views are supported in SQL
@@ -7492,7 +7969,7 @@ var Schema = class {
   //     defineView(name, false, paramsOrRet as Params, retOrFn, maybeFn!);
   //   }
   // }
-  anonymousView(opts, ret, fn) {
+  anonymousView(opts, ret, fn, ..._) {
     return makeAnonViewExport(this.#ctx, opts, {}, ret, fn);
   }
   procedure(...args) {
@@ -7514,6 +7991,21 @@ var Schema = class {
     }
     return makeProcedureExport(this.#ctx, opts, params, ret, fn);
   }
+  httpHandler(...args) {
+    let opts, fn;
+    switch (args.length) {
+      case 1:
+        [fn] = args;
+        break;
+      case 2:
+        [opts, fn] = args;
+        break;
+    }
+    return makeHttpHandlerExport(this.#ctx, opts, fn);
+  }
+  httpRouter(router) {
+    return makeHttpRouterExport(this.#ctx, router);
+  }
   /**
    * Bundle multiple reducers, procedures, etc into one value to export.
    * The name they will be exported with is their corresponding key in the `exports` argument.
@@ -7678,6 +8170,6 @@ statuses/index.js:
    *)
 */
 
-export { ArrayBuilder, ArrayColumnBuilder, BoolBuilder, BoolColumnBuilder, BooleanExpr, ByteArrayBuilder, ByteArrayColumnBuilder, CaseConversionPolicy, ColumnBuilder, ColumnExpression, ConnectionIdBuilder, ConnectionIdColumnBuilder, F32Builder, F32ColumnBuilder, F64Builder, F64ColumnBuilder, I128Builder, I128ColumnBuilder, I16Builder, I16ColumnBuilder, I256Builder, I256ColumnBuilder, I32Builder, I32ColumnBuilder, I64Builder, I64ColumnBuilder, I8Builder, I8ColumnBuilder, IdentityBuilder, IdentityColumnBuilder, OptionBuilder, OptionColumnBuilder, ProductBuilder, ProductColumnBuilder, Range, RefBuilder, ResultBuilder, ResultColumnBuilder, RowBuilder, ScheduleAtBuilder, ScheduleAtColumnBuilder, SenderError, SimpleSumBuilder, SimpleSumColumnBuilder, SpacetimeHostError, StringBuilder, StringColumnBuilder, SumBuilder, SumColumnBuilder, TimeDurationBuilder, TimeDurationColumnBuilder, TimestampBuilder, TimestampColumnBuilder, TypeBuilder, U128Builder, U128ColumnBuilder, U16Builder, U16ColumnBuilder, U256Builder, U256ColumnBuilder, U32Builder, U32ColumnBuilder, U64Builder, U64ColumnBuilder, U8Builder, U8ColumnBuilder, UuidBuilder, UuidColumnBuilder, and, createTableRefFromDef, errors, evaluateBooleanExpr, getQueryAccessorName, getQueryTableName, getQueryWhereClause, isRowTypedQuery, isTypedQuery, literal, makeQueryBuilder, not, or, schema, t, table, toCamelCase, toComparableValue, toSql };
+export { ArrayBuilder, ArrayColumnBuilder, BoolBuilder, BoolColumnBuilder, BooleanExpr, ByteArrayBuilder, ByteArrayColumnBuilder, CaseConversionPolicy, ColumnBuilder, ColumnExpression, ConnectionIdBuilder, ConnectionIdColumnBuilder, F32Builder, F32ColumnBuilder, F64Builder, F64ColumnBuilder, I128Builder, I128ColumnBuilder, I16Builder, I16ColumnBuilder, I256Builder, I256ColumnBuilder, I32Builder, I32ColumnBuilder, I64Builder, I64ColumnBuilder, I8Builder, I8ColumnBuilder, IdentityBuilder, IdentityColumnBuilder, OptionBuilder, OptionColumnBuilder, ProductBuilder, ProductColumnBuilder, Range, RefBuilder, Request, ResultBuilder, ResultColumnBuilder, Router, RowBuilder, ScheduleAtBuilder, ScheduleAtColumnBuilder, SenderError, SimpleSumBuilder, SimpleSumColumnBuilder, SpacetimeHostError, StringBuilder, StringColumnBuilder, SumBuilder, SumColumnBuilder, SyncResponse, TimeDurationBuilder, TimeDurationColumnBuilder, TimestampBuilder, TimestampColumnBuilder, TypeBuilder, U128Builder, U128ColumnBuilder, U16Builder, U16ColumnBuilder, U256Builder, U256ColumnBuilder, U32Builder, U32ColumnBuilder, U64Builder, U64ColumnBuilder, U8Builder, U8ColumnBuilder, UuidBuilder, UuidColumnBuilder, and, createTableRefFromDef, errors, evaluateBooleanExpr, getQueryAccessorName, getQueryTableName, getQueryWhereClause, isRowTypedQuery, isTypedQuery, literal, makeQueryBuilder, not, or, schema, t, table, toCamelCase, toComparableValue, toSql };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map