6385 lines
714 KiB
JavaScript
6385 lines
714 KiB
JavaScript
import * as _syscalls2_0 from "spacetime:[email protected]";
|
||
import { moduleHooks } from "spacetime:[email protected]";
|
||
|
||
//#region node_modules/.pnpm/[email protected]/node_modules/headers-polyfill/lib/index.mjs
|
||
var __create$1 = Object.create;
|
||
var __defProp$1 = Object.defineProperty;
|
||
var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
|
||
var __getOwnPropNames$1 = Object.getOwnPropertyNames;
|
||
var __getProtoOf$1 = Object.getPrototypeOf;
|
||
var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
|
||
var __commonJS$1 = (cb, mod) => function __require() {
|
||
return mod || (0, cb[__getOwnPropNames$1(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
|
||
};
|
||
var __copyProps$1 = (to, from, except, desc) => {
|
||
if (from && typeof from === "object" || typeof from === "function") {
|
||
for (let key of __getOwnPropNames$1(from)) if (!__hasOwnProp$1.call(to, key) && key !== except) __defProp$1(to, key, {
|
||
get: () => from[key],
|
||
enumerable: !(desc = __getOwnPropDesc$1(from, key)) || desc.enumerable
|
||
});
|
||
}
|
||
return to;
|
||
};
|
||
var __toESM$1 = (mod, isNodeMode, target) => (target = mod != null ? __create$1(__getProtoOf$1(mod)) : {}, __copyProps$1(isNodeMode || !mod || !mod.__esModule ? __defProp$1(target, "default", {
|
||
value: mod,
|
||
enumerable: true
|
||
}) : target, mod));
|
||
var import_set_cookie_parser = __toESM$1(__commonJS$1({ "node_modules/set-cookie-parser/lib/set-cookie.js"(exports, module) {
|
||
"use strict";
|
||
var defaultParseOptions = {
|
||
decodeValues: true,
|
||
map: false,
|
||
silent: false
|
||
};
|
||
function isNonEmptyString(str) {
|
||
return typeof str === "string" && !!str.trim();
|
||
}
|
||
function parseString(setCookieValue, options) {
|
||
var parts = setCookieValue.split(";").filter(isNonEmptyString);
|
||
var parsed = parseNameValuePair(parts.shift());
|
||
var name = parsed.name;
|
||
var value = parsed.value;
|
||
options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
|
||
try {
|
||
value = options.decodeValues ? decodeURIComponent(value) : value;
|
||
} catch (e) {
|
||
console.error("set-cookie-parser encountered an error while decoding a cookie with value '" + value + "'. Set options.decodeValues to false to disable this feature.", e);
|
||
}
|
||
var cookie = {
|
||
name,
|
||
value
|
||
};
|
||
parts.forEach(function(part) {
|
||
var sides = part.split("=");
|
||
var key = sides.shift().trimLeft().toLowerCase();
|
||
var value2 = sides.join("=");
|
||
if (key === "expires") cookie.expires = new Date(value2);
|
||
else if (key === "max-age") cookie.maxAge = parseInt(value2, 10);
|
||
else if (key === "secure") cookie.secure = true;
|
||
else if (key === "httponly") cookie.httpOnly = true;
|
||
else if (key === "samesite") cookie.sameSite = value2;
|
||
else cookie[key] = value2;
|
||
});
|
||
return cookie;
|
||
}
|
||
function parseNameValuePair(nameValuePairStr) {
|
||
var name = "";
|
||
var value = "";
|
||
var nameValueArr = nameValuePairStr.split("=");
|
||
if (nameValueArr.length > 1) {
|
||
name = nameValueArr.shift();
|
||
value = nameValueArr.join("=");
|
||
} else value = nameValuePairStr;
|
||
return {
|
||
name,
|
||
value
|
||
};
|
||
}
|
||
function parse(input, options) {
|
||
options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
|
||
if (!input) if (!options.map) return [];
|
||
else return {};
|
||
if (input.headers) if (typeof input.headers.getSetCookie === "function") input = input.headers.getSetCookie();
|
||
else if (input.headers["set-cookie"]) input = input.headers["set-cookie"];
|
||
else {
|
||
var sch = input.headers[Object.keys(input.headers).find(function(key) {
|
||
return key.toLowerCase() === "set-cookie";
|
||
})];
|
||
if (!sch && input.headers.cookie && !options.silent) console.warn("Warning: set-cookie-parser appears to have been called on a request object. It is designed to parse Set-Cookie headers from responses, not Cookie headers from requests. Set the option {silent: true} to suppress this warning.");
|
||
input = sch;
|
||
}
|
||
if (!Array.isArray(input)) input = [input];
|
||
options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
|
||
if (!options.map) return input.filter(isNonEmptyString).map(function(str) {
|
||
return parseString(str, options);
|
||
});
|
||
else return input.filter(isNonEmptyString).reduce(function(cookies2, str) {
|
||
var cookie = parseString(str, options);
|
||
cookies2[cookie.name] = cookie;
|
||
return cookies2;
|
||
}, {});
|
||
}
|
||
function splitCookiesString2(cookiesString) {
|
||
if (Array.isArray(cookiesString)) return cookiesString;
|
||
if (typeof cookiesString !== "string") return [];
|
||
var cookiesStrings = [];
|
||
var pos = 0;
|
||
var start;
|
||
var ch;
|
||
var lastComma;
|
||
var nextStart;
|
||
var cookiesSeparatorFound;
|
||
function skipWhitespace() {
|
||
while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) pos += 1;
|
||
return pos < cookiesString.length;
|
||
}
|
||
function notSpecialChar() {
|
||
ch = cookiesString.charAt(pos);
|
||
return ch !== "=" && ch !== ";" && ch !== ",";
|
||
}
|
||
while (pos < cookiesString.length) {
|
||
start = pos;
|
||
cookiesSeparatorFound = false;
|
||
while (skipWhitespace()) {
|
||
ch = cookiesString.charAt(pos);
|
||
if (ch === ",") {
|
||
lastComma = pos;
|
||
pos += 1;
|
||
skipWhitespace();
|
||
nextStart = pos;
|
||
while (pos < cookiesString.length && notSpecialChar()) pos += 1;
|
||
if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
|
||
cookiesSeparatorFound = true;
|
||
pos = nextStart;
|
||
cookiesStrings.push(cookiesString.substring(start, lastComma));
|
||
start = pos;
|
||
} else pos = lastComma + 1;
|
||
} else pos += 1;
|
||
}
|
||
if (!cookiesSeparatorFound || pos >= cookiesString.length) cookiesStrings.push(cookiesString.substring(start, cookiesString.length));
|
||
}
|
||
return cookiesStrings;
|
||
}
|
||
module.exports = parse;
|
||
module.exports.parse = parse;
|
||
module.exports.parseString = parseString;
|
||
module.exports.splitCookiesString = splitCookiesString2;
|
||
} })());
|
||
var HEADERS_INVALID_CHARACTERS = /[^a-z0-9\-#$%&'*+.^_`|~]/i;
|
||
function normalizeHeaderName(name) {
|
||
if (HEADERS_INVALID_CHARACTERS.test(name) || name.trim() === "") throw new TypeError("Invalid character in header field name");
|
||
return name.trim().toLowerCase();
|
||
}
|
||
var charCodesToRemove = [
|
||
String.fromCharCode(10),
|
||
String.fromCharCode(13),
|
||
String.fromCharCode(9),
|
||
String.fromCharCode(32)
|
||
];
|
||
var HEADER_VALUE_REMOVE_REGEXP = new RegExp(`(^[${charCodesToRemove.join("")}]|$[${charCodesToRemove.join("")}])`, "g");
|
||
function normalizeHeaderValue(value) {
|
||
return value.replace(HEADER_VALUE_REMOVE_REGEXP, "");
|
||
}
|
||
function isValidHeaderName(value) {
|
||
if (typeof value !== "string") return false;
|
||
if (value.length === 0) return false;
|
||
for (let i = 0; i < value.length; i++) {
|
||
const character = value.charCodeAt(i);
|
||
if (character > 127 || !isToken(character)) return false;
|
||
}
|
||
return true;
|
||
}
|
||
function isToken(value) {
|
||
return ![
|
||
127,
|
||
32,
|
||
"(",
|
||
")",
|
||
"<",
|
||
">",
|
||
"@",
|
||
",",
|
||
";",
|
||
":",
|
||
"\\",
|
||
"\"",
|
||
"/",
|
||
"[",
|
||
"]",
|
||
"?",
|
||
"=",
|
||
"{",
|
||
"}"
|
||
].includes(value);
|
||
}
|
||
function isValidHeaderValue(value) {
|
||
if (typeof value !== "string") return false;
|
||
if (value.trim() !== value) return false;
|
||
for (let i = 0; i < value.length; i++) {
|
||
const character = value.charCodeAt(i);
|
||
if (character === 0 || character === 10 || character === 13) return false;
|
||
}
|
||
return true;
|
||
}
|
||
var NORMALIZED_HEADERS = Symbol("normalizedHeaders");
|
||
var RAW_HEADER_NAMES = Symbol("rawHeaderNames");
|
||
var HEADER_VALUE_DELIMITER = ", ";
|
||
var _a, _b, _c;
|
||
var Headers = class _Headers {
|
||
constructor(init) {
|
||
this[_a] = {};
|
||
this[_b] = /* @__PURE__ */ new Map();
|
||
this[_c] = "Headers";
|
||
if (["Headers", "HeadersPolyfill"].includes(init?.constructor.name) || init instanceof _Headers || typeof globalThis.Headers !== "undefined" && init instanceof globalThis.Headers) init.forEach((value, name) => {
|
||
this.append(name, value);
|
||
}, this);
|
||
else if (Array.isArray(init)) init.forEach(([name, value]) => {
|
||
this.append(name, Array.isArray(value) ? value.join(HEADER_VALUE_DELIMITER) : value);
|
||
});
|
||
else if (init) Object.getOwnPropertyNames(init).forEach((name) => {
|
||
const value = init[name];
|
||
this.append(name, Array.isArray(value) ? value.join(HEADER_VALUE_DELIMITER) : value);
|
||
});
|
||
}
|
||
[(_a = NORMALIZED_HEADERS, _b = RAW_HEADER_NAMES, _c = Symbol.toStringTag, Symbol.iterator)]() {
|
||
return this.entries();
|
||
}
|
||
*keys() {
|
||
for (const [name] of this.entries()) yield name;
|
||
}
|
||
*values() {
|
||
for (const [, value] of this.entries()) yield value;
|
||
}
|
||
*entries() {
|
||
let sortedKeys = Object.keys(this[NORMALIZED_HEADERS]).sort((a, b) => a.localeCompare(b));
|
||
for (const name of sortedKeys) if (name === "set-cookie") for (const value of this.getSetCookie()) yield [name, value];
|
||
else yield [name, this.get(name)];
|
||
}
|
||
/**
|
||
* Returns a boolean stating whether a `Headers` object contains a certain header.
|
||
*/
|
||
has(name) {
|
||
if (!isValidHeaderName(name)) throw new TypeError(`Invalid header name "${name}"`);
|
||
return this[NORMALIZED_HEADERS].hasOwnProperty(normalizeHeaderName(name));
|
||
}
|
||
/**
|
||
* Returns a `ByteString` sequence of all the values of a header with a given name.
|
||
*/
|
||
get(name) {
|
||
if (!isValidHeaderName(name)) throw TypeError(`Invalid header name "${name}"`);
|
||
return this[NORMALIZED_HEADERS][normalizeHeaderName(name)] ?? null;
|
||
}
|
||
/**
|
||
* Sets a new value for an existing header inside a `Headers` object, or adds the header if it does not already exist.
|
||
*/
|
||
set(name, value) {
|
||
if (!isValidHeaderName(name) || !isValidHeaderValue(value)) return;
|
||
const normalizedName = normalizeHeaderName(name);
|
||
const normalizedValue = normalizeHeaderValue(value);
|
||
this[NORMALIZED_HEADERS][normalizedName] = normalizeHeaderValue(normalizedValue);
|
||
this[RAW_HEADER_NAMES].set(normalizedName, name);
|
||
}
|
||
/**
|
||
* Appends a new value onto an existing header inside a `Headers` object, or adds the header if it does not already exist.
|
||
*/
|
||
append(name, value) {
|
||
if (!isValidHeaderName(name) || !isValidHeaderValue(value)) return;
|
||
const normalizedName = normalizeHeaderName(name);
|
||
const normalizedValue = normalizeHeaderValue(value);
|
||
let resolvedValue = this.has(normalizedName) ? `${this.get(normalizedName)}, ${normalizedValue}` : normalizedValue;
|
||
this.set(name, resolvedValue);
|
||
}
|
||
/**
|
||
* Deletes a header from the `Headers` object.
|
||
*/
|
||
delete(name) {
|
||
if (!isValidHeaderName(name)) return;
|
||
if (!this.has(name)) return;
|
||
const normalizedName = normalizeHeaderName(name);
|
||
delete this[NORMALIZED_HEADERS][normalizedName];
|
||
this[RAW_HEADER_NAMES].delete(normalizedName);
|
||
}
|
||
/**
|
||
* Traverses the `Headers` object,
|
||
* calling the given callback for each header.
|
||
*/
|
||
forEach(callback, thisArg) {
|
||
for (const [name, value] of this.entries()) callback.call(thisArg, value, name, this);
|
||
}
|
||
/**
|
||
* Returns an array containing the values
|
||
* of all Set-Cookie headers associated
|
||
* with a response
|
||
*/
|
||
getSetCookie() {
|
||
const setCookieHeader = this.get("set-cookie");
|
||
if (setCookieHeader === null) return [];
|
||
if (setCookieHeader === "") return [""];
|
||
return (0, import_set_cookie_parser.splitCookiesString)(setCookieHeader);
|
||
}
|
||
};
|
||
function headersToList(headers) {
|
||
const headersList = [];
|
||
headers.forEach((value, name) => {
|
||
const resolvedValue = value.includes(",") ? value.split(",").map((value2) => value2.trim()) : value;
|
||
headersList.push([name, resolvedValue]);
|
||
});
|
||
return headersList;
|
||
}
|
||
|
||
//#endregion
|
||
//#region node_modules/.pnpm/[email protected]/node_modules/spacetimedb/dist/server/index.mjs
|
||
typeof globalThis !== "undefined" && (globalThis.global = globalThis.global || globalThis, globalThis.window = globalThis.window || globalThis);
|
||
var __create = Object.create;
|
||
var __defProp = Object.defineProperty;
|
||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
||
var __getOwnPropNames = Object.getOwnPropertyNames;
|
||
var __getProtoOf = Object.getPrototypeOf;
|
||
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
||
var __esm = (fn, res) => function __init() {
|
||
return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
|
||
};
|
||
var __commonJS = (cb, mod) => function __require() {
|
||
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
|
||
};
|
||
var __export = (target, all) => {
|
||
for (var name in all) __defProp(target, name, {
|
||
get: all[name],
|
||
enumerable: true
|
||
});
|
||
};
|
||
var __copyProps = (to, from, except, desc) => {
|
||
if (from && typeof from === "object" || typeof from === "function") {
|
||
for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
|
||
get: () => from[key],
|
||
enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
|
||
});
|
||
}
|
||
return to;
|
||
};
|
||
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(__defProp(target, "default", {
|
||
value: mod,
|
||
enumerable: true
|
||
}), mod));
|
||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
||
var require_base64_js = __commonJS({ "../../node_modules/.pnpm/[email protected]/node_modules/base64-js/index.js"(exports) {
|
||
exports.byteLength = byteLength;
|
||
exports.toByteArray = toByteArray;
|
||
exports.fromByteArray = fromByteArray2;
|
||
var lookup = [];
|
||
var revLookup = [];
|
||
var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
|
||
var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
||
for (i = 0, len = code.length; i < len; ++i) {
|
||
lookup[i] = code[i];
|
||
revLookup[code.charCodeAt(i)] = i;
|
||
}
|
||
var i;
|
||
var len;
|
||
revLookup["-".charCodeAt(0)] = 62;
|
||
revLookup["_".charCodeAt(0)] = 63;
|
||
function getLens(b64) {
|
||
var len2 = b64.length;
|
||
if (len2 % 4 > 0) throw new Error("Invalid string. Length must be a multiple of 4");
|
||
var validLen = b64.indexOf("=");
|
||
if (validLen === -1) validLen = len2;
|
||
var placeHoldersLen = validLen === len2 ? 0 : 4 - validLen % 4;
|
||
return [validLen, placeHoldersLen];
|
||
}
|
||
function byteLength(b64) {
|
||
var lens = getLens(b64);
|
||
var validLen = lens[0];
|
||
var placeHoldersLen = lens[1];
|
||
return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
|
||
}
|
||
function _byteLength(b64, validLen, placeHoldersLen) {
|
||
return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
|
||
}
|
||
function toByteArray(b64) {
|
||
var tmp;
|
||
var lens = getLens(b64);
|
||
var validLen = lens[0];
|
||
var placeHoldersLen = lens[1];
|
||
var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
|
||
var curByte = 0;
|
||
var len2 = placeHoldersLen > 0 ? validLen - 4 : validLen;
|
||
var i2;
|
||
for (i2 = 0; i2 < len2; i2 += 4) {
|
||
tmp = revLookup[b64.charCodeAt(i2)] << 18 | revLookup[b64.charCodeAt(i2 + 1)] << 12 | revLookup[b64.charCodeAt(i2 + 2)] << 6 | revLookup[b64.charCodeAt(i2 + 3)];
|
||
arr[curByte++] = tmp >> 16 & 255;
|
||
arr[curByte++] = tmp >> 8 & 255;
|
||
arr[curByte++] = tmp & 255;
|
||
}
|
||
if (placeHoldersLen === 2) {
|
||
tmp = revLookup[b64.charCodeAt(i2)] << 2 | revLookup[b64.charCodeAt(i2 + 1)] >> 4;
|
||
arr[curByte++] = tmp & 255;
|
||
}
|
||
if (placeHoldersLen === 1) {
|
||
tmp = revLookup[b64.charCodeAt(i2)] << 10 | revLookup[b64.charCodeAt(i2 + 1)] << 4 | revLookup[b64.charCodeAt(i2 + 2)] >> 2;
|
||
arr[curByte++] = tmp >> 8 & 255;
|
||
arr[curByte++] = tmp & 255;
|
||
}
|
||
return arr;
|
||
}
|
||
function tripletToBase64(num) {
|
||
return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
|
||
}
|
||
function encodeChunk(uint8, start, end) {
|
||
var tmp;
|
||
var output = [];
|
||
for (var i2 = start; i2 < end; i2 += 3) {
|
||
tmp = (uint8[i2] << 16 & 16711680) + (uint8[i2 + 1] << 8 & 65280) + (uint8[i2 + 2] & 255);
|
||
output.push(tripletToBase64(tmp));
|
||
}
|
||
return output.join("");
|
||
}
|
||
function fromByteArray2(uint8) {
|
||
var tmp;
|
||
var len2 = uint8.length;
|
||
var extraBytes = len2 % 3;
|
||
var parts = [];
|
||
var maxChunkLength = 16383;
|
||
for (var i2 = 0, len22 = len2 - extraBytes; i2 < len22; i2 += maxChunkLength) parts.push(encodeChunk(uint8, i2, i2 + maxChunkLength > len22 ? len22 : i2 + maxChunkLength));
|
||
if (extraBytes === 1) {
|
||
tmp = uint8[len2 - 1];
|
||
parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "==");
|
||
} else if (extraBytes === 2) {
|
||
tmp = (uint8[len2 - 2] << 8) + uint8[len2 - 1];
|
||
parts.push(lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "=");
|
||
}
|
||
return parts.join("");
|
||
}
|
||
} });
|
||
var require_codes = __commonJS({ "../../node_modules/.pnpm/[email protected]/node_modules/statuses/codes.json"(exports, module) {
|
||
module.exports = {
|
||
"100": "Continue",
|
||
"101": "Switching Protocols",
|
||
"102": "Processing",
|
||
"103": "Early Hints",
|
||
"200": "OK",
|
||
"201": "Created",
|
||
"202": "Accepted",
|
||
"203": "Non-Authoritative Information",
|
||
"204": "No Content",
|
||
"205": "Reset Content",
|
||
"206": "Partial Content",
|
||
"207": "Multi-Status",
|
||
"208": "Already Reported",
|
||
"226": "IM Used",
|
||
"300": "Multiple Choices",
|
||
"301": "Moved Permanently",
|
||
"302": "Found",
|
||
"303": "See Other",
|
||
"304": "Not Modified",
|
||
"305": "Use Proxy",
|
||
"307": "Temporary Redirect",
|
||
"308": "Permanent Redirect",
|
||
"400": "Bad Request",
|
||
"401": "Unauthorized",
|
||
"402": "Payment Required",
|
||
"403": "Forbidden",
|
||
"404": "Not Found",
|
||
"405": "Method Not Allowed",
|
||
"406": "Not Acceptable",
|
||
"407": "Proxy Authentication Required",
|
||
"408": "Request Timeout",
|
||
"409": "Conflict",
|
||
"410": "Gone",
|
||
"411": "Length Required",
|
||
"412": "Precondition Failed",
|
||
"413": "Payload Too Large",
|
||
"414": "URI Too Long",
|
||
"415": "Unsupported Media Type",
|
||
"416": "Range Not Satisfiable",
|
||
"417": "Expectation Failed",
|
||
"418": "I'm a Teapot",
|
||
"421": "Misdirected Request",
|
||
"422": "Unprocessable Entity",
|
||
"423": "Locked",
|
||
"424": "Failed Dependency",
|
||
"425": "Too Early",
|
||
"426": "Upgrade Required",
|
||
"428": "Precondition Required",
|
||
"429": "Too Many Requests",
|
||
"431": "Request Header Fields Too Large",
|
||
"451": "Unavailable For Legal Reasons",
|
||
"500": "Internal Server Error",
|
||
"501": "Not Implemented",
|
||
"502": "Bad Gateway",
|
||
"503": "Service Unavailable",
|
||
"504": "Gateway Timeout",
|
||
"505": "HTTP Version Not Supported",
|
||
"506": "Variant Also Negotiates",
|
||
"507": "Insufficient Storage",
|
||
"508": "Loop Detected",
|
||
"509": "Bandwidth Limit Exceeded",
|
||
"510": "Not Extended",
|
||
"511": "Network Authentication Required"
|
||
};
|
||
} });
|
||
var require_statuses = __commonJS({ "../../node_modules/.pnpm/[email protected]/node_modules/statuses/index.js"(exports, module) {
|
||
var codes = require_codes();
|
||
module.exports = status2;
|
||
status2.message = codes;
|
||
status2.code = createMessageToStatusCodeMap(codes);
|
||
status2.codes = createStatusCodeList(codes);
|
||
status2.redirect = {
|
||
300: true,
|
||
301: true,
|
||
302: true,
|
||
303: true,
|
||
305: true,
|
||
307: true,
|
||
308: true
|
||
};
|
||
status2.empty = {
|
||
204: true,
|
||
205: true,
|
||
304: true
|
||
};
|
||
status2.retry = {
|
||
502: true,
|
||
503: true,
|
||
504: true
|
||
};
|
||
function createMessageToStatusCodeMap(codes2) {
|
||
var map = {};
|
||
Object.keys(codes2).forEach(function forEachCode(code) {
|
||
var message = codes2[code];
|
||
var status3 = Number(code);
|
||
map[message.toLowerCase()] = status3;
|
||
});
|
||
return map;
|
||
}
|
||
function createStatusCodeList(codes2) {
|
||
return Object.keys(codes2).map(function mapCode(code) {
|
||
return Number(code);
|
||
});
|
||
}
|
||
function getStatusCode(message) {
|
||
var msg = message.toLowerCase();
|
||
if (!Object.prototype.hasOwnProperty.call(status2.code, msg)) throw new Error("invalid status message: \"" + message + "\"");
|
||
return status2.code[msg];
|
||
}
|
||
function getStatusMessage(code) {
|
||
if (!Object.prototype.hasOwnProperty.call(status2.message, code)) throw new Error("invalid status code: " + code);
|
||
return status2.message[code];
|
||
}
|
||
function status2(code) {
|
||
if (typeof code === "number") return getStatusMessage(code);
|
||
if (typeof code !== "string") throw new TypeError("code must be a number or string");
|
||
var n = parseInt(code, 10);
|
||
if (!isNaN(n)) return getStatusMessage(n);
|
||
return getStatusCode(code);
|
||
}
|
||
} });
|
||
var util_stub_exports = {};
|
||
__export(util_stub_exports, { inspect: () => inspect });
|
||
var inspect;
|
||
var init_util_stub = __esm({ "src/util-stub.ts"() {
|
||
inspect = {};
|
||
} });
|
||
var require_util_inspect = __commonJS({ "../../node_modules/.pnpm/[email protected]/node_modules/object-inspect/util.inspect.js"(exports, module) {
|
||
module.exports = (init_util_stub(), __toCommonJS(util_stub_exports)).inspect;
|
||
} });
|
||
var require_object_inspect = __commonJS({ "../../node_modules/.pnpm/[email protected]/node_modules/object-inspect/index.js"(exports, module) {
|
||
var hasMap = typeof Map === "function" && Map.prototype;
|
||
var mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ? Object.getOwnPropertyDescriptor(Map.prototype, "size") : null;
|
||
var mapSize = hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get === "function" ? mapSizeDescriptor.get : null;
|
||
var mapForEach = hasMap && Map.prototype.forEach;
|
||
var hasSet = typeof Set === "function" && Set.prototype;
|
||
var setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ? Object.getOwnPropertyDescriptor(Set.prototype, "size") : null;
|
||
var setSize = hasSet && setSizeDescriptor && typeof setSizeDescriptor.get === "function" ? setSizeDescriptor.get : null;
|
||
var setForEach = hasSet && Set.prototype.forEach;
|
||
var weakMapHas = typeof WeakMap === "function" && WeakMap.prototype ? WeakMap.prototype.has : null;
|
||
var weakSetHas = typeof WeakSet === "function" && WeakSet.prototype ? WeakSet.prototype.has : null;
|
||
var weakRefDeref = typeof WeakRef === "function" && WeakRef.prototype ? WeakRef.prototype.deref : null;
|
||
var booleanValueOf = Boolean.prototype.valueOf;
|
||
var objectToString = Object.prototype.toString;
|
||
var functionToString = Function.prototype.toString;
|
||
var $match = String.prototype.match;
|
||
var $slice = String.prototype.slice;
|
||
var $replace = String.prototype.replace;
|
||
var $toUpperCase = String.prototype.toUpperCase;
|
||
var $toLowerCase = String.prototype.toLowerCase;
|
||
var $test = RegExp.prototype.test;
|
||
var $concat = Array.prototype.concat;
|
||
var $join = Array.prototype.join;
|
||
var $arrSlice = Array.prototype.slice;
|
||
var $floor = Math.floor;
|
||
var bigIntValueOf = typeof BigInt === "function" ? BigInt.prototype.valueOf : null;
|
||
var gOPS = Object.getOwnPropertySymbols;
|
||
var symToString = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? Symbol.prototype.toString : null;
|
||
var hasShammedSymbols = typeof Symbol === "function" && typeof Symbol.iterator === "object";
|
||
var toStringTag = typeof Symbol === "function" && Symbol.toStringTag && (typeof Symbol.toStringTag === hasShammedSymbols ? "object" : "symbol") ? Symbol.toStringTag : null;
|
||
var isEnumerable = Object.prototype.propertyIsEnumerable;
|
||
var gPO = (typeof Reflect === "function" ? Reflect.getPrototypeOf : Object.getPrototypeOf) || ([].__proto__ === Array.prototype ? function(O) {
|
||
return O.__proto__;
|
||
} : null);
|
||
function addNumericSeparator(num, str) {
|
||
if (num === Infinity || num === -Infinity || num !== num || num && num > -1e3 && num < 1e3 || $test.call(/e/, str)) return str;
|
||
var sepRegex = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g;
|
||
if (typeof num === "number") {
|
||
var int = num < 0 ? -$floor(-num) : $floor(num);
|
||
if (int !== num) {
|
||
var intStr = String(int);
|
||
var dec = $slice.call(str, intStr.length + 1);
|
||
return $replace.call(intStr, sepRegex, "$&_") + "." + $replace.call($replace.call(dec, /([0-9]{3})/g, "$&_"), /_$/, "");
|
||
}
|
||
}
|
||
return $replace.call(str, sepRegex, "$&_");
|
||
}
|
||
var utilInspect = require_util_inspect();
|
||
var inspectCustom = utilInspect.custom;
|
||
var inspectSymbol = isSymbol(inspectCustom) ? inspectCustom : null;
|
||
var quotes = {
|
||
__proto__: null,
|
||
"double": "\"",
|
||
single: "'"
|
||
};
|
||
var quoteREs = {
|
||
__proto__: null,
|
||
"double": /(["\\])/g,
|
||
single: /(['\\])/g
|
||
};
|
||
module.exports = function inspect_(obj, options, depth, seen) {
|
||
var opts = options || {};
|
||
if (has(opts, "quoteStyle") && !has(quotes, opts.quoteStyle)) throw new TypeError("option \"quoteStyle\" must be \"single\" or \"double\"");
|
||
if (has(opts, "maxStringLength") && (typeof opts.maxStringLength === "number" ? opts.maxStringLength < 0 && opts.maxStringLength !== Infinity : opts.maxStringLength !== null)) throw new TypeError("option \"maxStringLength\", if provided, must be a positive integer, Infinity, or `null`");
|
||
var customInspect = has(opts, "customInspect") ? opts.customInspect : true;
|
||
if (typeof customInspect !== "boolean" && customInspect !== "symbol") throw new TypeError("option \"customInspect\", if provided, must be `true`, `false`, or `'symbol'`");
|
||
if (has(opts, "indent") && opts.indent !== null && opts.indent !== " " && !(parseInt(opts.indent, 10) === opts.indent && opts.indent > 0)) throw new TypeError("option \"indent\" must be \"\\t\", an integer > 0, or `null`");
|
||
if (has(opts, "numericSeparator") && typeof opts.numericSeparator !== "boolean") throw new TypeError("option \"numericSeparator\", if provided, must be `true` or `false`");
|
||
var numericSeparator = opts.numericSeparator;
|
||
if (typeof obj === "undefined") return "undefined";
|
||
if (obj === null) return "null";
|
||
if (typeof obj === "boolean") return obj ? "true" : "false";
|
||
if (typeof obj === "string") return inspectString(obj, opts);
|
||
if (typeof obj === "number") {
|
||
if (obj === 0) return Infinity / obj > 0 ? "0" : "-0";
|
||
var str = String(obj);
|
||
return numericSeparator ? addNumericSeparator(obj, str) : str;
|
||
}
|
||
if (typeof obj === "bigint") {
|
||
var bigIntStr = String(obj) + "n";
|
||
return numericSeparator ? addNumericSeparator(obj, bigIntStr) : bigIntStr;
|
||
}
|
||
var maxDepth = typeof opts.depth === "undefined" ? 5 : opts.depth;
|
||
if (typeof depth === "undefined") depth = 0;
|
||
if (depth >= maxDepth && maxDepth > 0 && typeof obj === "object") return isArray(obj) ? "[Array]" : "[Object]";
|
||
var indent = getIndent(opts, depth);
|
||
if (typeof seen === "undefined") seen = [];
|
||
else if (indexOf(seen, obj) >= 0) return "[Circular]";
|
||
function inspect3(value, from, noIndent) {
|
||
if (from) {
|
||
seen = $arrSlice.call(seen);
|
||
seen.push(from);
|
||
}
|
||
if (noIndent) {
|
||
var newOpts = { depth: opts.depth };
|
||
if (has(opts, "quoteStyle")) newOpts.quoteStyle = opts.quoteStyle;
|
||
return inspect_(value, newOpts, depth + 1, seen);
|
||
}
|
||
return inspect_(value, opts, depth + 1, seen);
|
||
}
|
||
if (typeof obj === "function" && !isRegExp(obj)) {
|
||
var name = nameOf(obj);
|
||
var keys = arrObjKeys(obj, inspect3);
|
||
return "[Function" + (name ? ": " + name : " (anonymous)") + "]" + (keys.length > 0 ? " { " + $join.call(keys, ", ") + " }" : "");
|
||
}
|
||
if (isSymbol(obj)) {
|
||
var symString = hasShammedSymbols ? $replace.call(String(obj), /^(Symbol\(.*\))_[^)]*$/, "$1") : symToString.call(obj);
|
||
return typeof obj === "object" && !hasShammedSymbols ? markBoxed(symString) : symString;
|
||
}
|
||
if (isElement(obj)) {
|
||
var s = "<" + $toLowerCase.call(String(obj.nodeName));
|
||
var attrs = obj.attributes || [];
|
||
for (var i = 0; i < attrs.length; i++) s += " " + attrs[i].name + "=" + wrapQuotes(quote(attrs[i].value), "double", opts);
|
||
s += ">";
|
||
if (obj.childNodes && obj.childNodes.length) s += "...";
|
||
s += "</" + $toLowerCase.call(String(obj.nodeName)) + ">";
|
||
return s;
|
||
}
|
||
if (isArray(obj)) {
|
||
if (obj.length === 0) return "[]";
|
||
var xs = arrObjKeys(obj, inspect3);
|
||
if (indent && !singleLineValues(xs)) return "[" + indentedJoin(xs, indent) + "]";
|
||
return "[ " + $join.call(xs, ", ") + " ]";
|
||
}
|
||
if (isError(obj)) {
|
||
var parts = arrObjKeys(obj, inspect3);
|
||
if (!("cause" in Error.prototype) && "cause" in obj && !isEnumerable.call(obj, "cause")) return "{ [" + String(obj) + "] " + $join.call($concat.call("[cause]: " + inspect3(obj.cause), parts), ", ") + " }";
|
||
if (parts.length === 0) return "[" + String(obj) + "]";
|
||
return "{ [" + String(obj) + "] " + $join.call(parts, ", ") + " }";
|
||
}
|
||
if (typeof obj === "object" && customInspect) {
|
||
if (inspectSymbol && typeof obj[inspectSymbol] === "function" && utilInspect) return utilInspect(obj, { depth: maxDepth - depth });
|
||
else if (customInspect !== "symbol" && typeof obj.inspect === "function") return obj.inspect();
|
||
}
|
||
if (isMap(obj)) {
|
||
var mapParts = [];
|
||
if (mapForEach) mapForEach.call(obj, function(value, key) {
|
||
mapParts.push(inspect3(key, obj, true) + " => " + inspect3(value, obj));
|
||
});
|
||
return collectionOf("Map", mapSize.call(obj), mapParts, indent);
|
||
}
|
||
if (isSet(obj)) {
|
||
var setParts = [];
|
||
if (setForEach) setForEach.call(obj, function(value) {
|
||
setParts.push(inspect3(value, obj));
|
||
});
|
||
return collectionOf("Set", setSize.call(obj), setParts, indent);
|
||
}
|
||
if (isWeakMap(obj)) return weakCollectionOf("WeakMap");
|
||
if (isWeakSet(obj)) return weakCollectionOf("WeakSet");
|
||
if (isWeakRef(obj)) return weakCollectionOf("WeakRef");
|
||
if (isNumber(obj)) return markBoxed(inspect3(Number(obj)));
|
||
if (isBigInt(obj)) return markBoxed(inspect3(bigIntValueOf.call(obj)));
|
||
if (isBoolean(obj)) return markBoxed(booleanValueOf.call(obj));
|
||
if (isString(obj)) return markBoxed(inspect3(String(obj)));
|
||
if (typeof window !== "undefined" && obj === window) return "{ [object Window] }";
|
||
if (typeof globalThis !== "undefined" && obj === globalThis || typeof global !== "undefined" && obj === global) return "{ [object globalThis] }";
|
||
if (!isDate(obj) && !isRegExp(obj)) {
|
||
var ys = arrObjKeys(obj, inspect3);
|
||
var isPlainObject = gPO ? gPO(obj) === Object.prototype : obj instanceof Object || obj.constructor === Object;
|
||
var protoTag = obj instanceof Object ? "" : "null prototype";
|
||
var stringTag = !isPlainObject && toStringTag && Object(obj) === obj && toStringTag in obj ? $slice.call(toStr(obj), 8, -1) : protoTag ? "Object" : "";
|
||
var tag = (isPlainObject || typeof obj.constructor !== "function" ? "" : obj.constructor.name ? obj.constructor.name + " " : "") + (stringTag || protoTag ? "[" + $join.call($concat.call([], stringTag || [], protoTag || []), ": ") + "] " : "");
|
||
if (ys.length === 0) return tag + "{}";
|
||
if (indent) return tag + "{" + indentedJoin(ys, indent) + "}";
|
||
return tag + "{ " + $join.call(ys, ", ") + " }";
|
||
}
|
||
return String(obj);
|
||
};
|
||
function wrapQuotes(s, defaultStyle, opts) {
|
||
var quoteChar = quotes[opts.quoteStyle || defaultStyle];
|
||
return quoteChar + s + quoteChar;
|
||
}
|
||
function quote(s) {
|
||
return $replace.call(String(s), /"/g, """);
|
||
}
|
||
function canTrustToString(obj) {
|
||
return !toStringTag || !(typeof obj === "object" && (toStringTag in obj || typeof obj[toStringTag] !== "undefined"));
|
||
}
|
||
function isArray(obj) {
|
||
return toStr(obj) === "[object Array]" && canTrustToString(obj);
|
||
}
|
||
function isDate(obj) {
|
||
return toStr(obj) === "[object Date]" && canTrustToString(obj);
|
||
}
|
||
function isRegExp(obj) {
|
||
return toStr(obj) === "[object RegExp]" && canTrustToString(obj);
|
||
}
|
||
function isError(obj) {
|
||
return toStr(obj) === "[object Error]" && canTrustToString(obj);
|
||
}
|
||
function isString(obj) {
|
||
return toStr(obj) === "[object String]" && canTrustToString(obj);
|
||
}
|
||
function isNumber(obj) {
|
||
return toStr(obj) === "[object Number]" && canTrustToString(obj);
|
||
}
|
||
function isBoolean(obj) {
|
||
return toStr(obj) === "[object Boolean]" && canTrustToString(obj);
|
||
}
|
||
function isSymbol(obj) {
|
||
if (hasShammedSymbols) return obj && typeof obj === "object" && obj instanceof Symbol;
|
||
if (typeof obj === "symbol") return true;
|
||
if (!obj || typeof obj !== "object" || !symToString) return false;
|
||
try {
|
||
symToString.call(obj);
|
||
return true;
|
||
} catch (e) {}
|
||
return false;
|
||
}
|
||
function isBigInt(obj) {
|
||
if (!obj || typeof obj !== "object" || !bigIntValueOf) return false;
|
||
try {
|
||
bigIntValueOf.call(obj);
|
||
return true;
|
||
} catch (e) {}
|
||
return false;
|
||
}
|
||
var hasOwn2 = Object.prototype.hasOwnProperty || function(key) {
|
||
return key in this;
|
||
};
|
||
function has(obj, key) {
|
||
return hasOwn2.call(obj, key);
|
||
}
|
||
function toStr(obj) {
|
||
return objectToString.call(obj);
|
||
}
|
||
function nameOf(f) {
|
||
if (f.name) return f.name;
|
||
var m = $match.call(functionToString.call(f), /^function\s*([\w$]+)/);
|
||
if (m) return m[1];
|
||
return null;
|
||
}
|
||
function indexOf(xs, x) {
|
||
if (xs.indexOf) return xs.indexOf(x);
|
||
for (var i = 0, l = xs.length; i < l; i++) if (xs[i] === x) return i;
|
||
return -1;
|
||
}
|
||
function isMap(x) {
|
||
if (!mapSize || !x || typeof x !== "object") return false;
|
||
try {
|
||
mapSize.call(x);
|
||
try {
|
||
setSize.call(x);
|
||
} catch (s) {
|
||
return true;
|
||
}
|
||
return x instanceof Map;
|
||
} catch (e) {}
|
||
return false;
|
||
}
|
||
function isWeakMap(x) {
|
||
if (!weakMapHas || !x || typeof x !== "object") return false;
|
||
try {
|
||
weakMapHas.call(x, weakMapHas);
|
||
try {
|
||
weakSetHas.call(x, weakSetHas);
|
||
} catch (s) {
|
||
return true;
|
||
}
|
||
return x instanceof WeakMap;
|
||
} catch (e) {}
|
||
return false;
|
||
}
|
||
function isWeakRef(x) {
|
||
if (!weakRefDeref || !x || typeof x !== "object") return false;
|
||
try {
|
||
weakRefDeref.call(x);
|
||
return true;
|
||
} catch (e) {}
|
||
return false;
|
||
}
|
||
function isSet(x) {
|
||
if (!setSize || !x || typeof x !== "object") return false;
|
||
try {
|
||
setSize.call(x);
|
||
try {
|
||
mapSize.call(x);
|
||
} catch (m) {
|
||
return true;
|
||
}
|
||
return x instanceof Set;
|
||
} catch (e) {}
|
||
return false;
|
||
}
|
||
function isWeakSet(x) {
|
||
if (!weakSetHas || !x || typeof x !== "object") return false;
|
||
try {
|
||
weakSetHas.call(x, weakSetHas);
|
||
try {
|
||
weakMapHas.call(x, weakMapHas);
|
||
} catch (s) {
|
||
return true;
|
||
}
|
||
return x instanceof WeakSet;
|
||
} catch (e) {}
|
||
return false;
|
||
}
|
||
function isElement(x) {
|
||
if (!x || typeof x !== "object") return false;
|
||
if (typeof HTMLElement !== "undefined" && x instanceof HTMLElement) return true;
|
||
return typeof x.nodeName === "string" && typeof x.getAttribute === "function";
|
||
}
|
||
function inspectString(str, opts) {
|
||
if (str.length > opts.maxStringLength) {
|
||
var remaining = str.length - opts.maxStringLength;
|
||
var trailer = "... " + remaining + " more character" + (remaining > 1 ? "s" : "");
|
||
return inspectString($slice.call(str, 0, opts.maxStringLength), opts) + trailer;
|
||
}
|
||
var quoteRE = quoteREs[opts.quoteStyle || "single"];
|
||
quoteRE.lastIndex = 0;
|
||
return wrapQuotes($replace.call($replace.call(str, quoteRE, "\\$1"), /[\x00-\x1f]/g, lowbyte), "single", opts);
|
||
}
|
||
function lowbyte(c) {
|
||
var n = c.charCodeAt(0);
|
||
var x = {
|
||
8: "b",
|
||
9: "t",
|
||
10: "n",
|
||
12: "f",
|
||
13: "r"
|
||
}[n];
|
||
if (x) return "\\" + x;
|
||
return "\\x" + (n < 16 ? "0" : "") + $toUpperCase.call(n.toString(16));
|
||
}
|
||
function markBoxed(str) {
|
||
return "Object(" + str + ")";
|
||
}
|
||
function weakCollectionOf(type) {
|
||
return type + " { ? }";
|
||
}
|
||
function collectionOf(type, size, entries, indent) {
|
||
var joinedEntries = indent ? indentedJoin(entries, indent) : $join.call(entries, ", ");
|
||
return type + " (" + size + ") {" + joinedEntries + "}";
|
||
}
|
||
function singleLineValues(xs) {
|
||
for (var i = 0; i < xs.length; i++) if (indexOf(xs[i], "\n") >= 0) return false;
|
||
return true;
|
||
}
|
||
function getIndent(opts, depth) {
|
||
var baseIndent;
|
||
if (opts.indent === " ") baseIndent = " ";
|
||
else if (typeof opts.indent === "number" && opts.indent > 0) baseIndent = $join.call(Array(opts.indent + 1), " ");
|
||
else return null;
|
||
return {
|
||
base: baseIndent,
|
||
prev: $join.call(Array(depth + 1), baseIndent)
|
||
};
|
||
}
|
||
function indentedJoin(xs, indent) {
|
||
if (xs.length === 0) return "";
|
||
var lineJoiner = "\n" + indent.prev + indent.base;
|
||
return lineJoiner + $join.call(xs, "," + lineJoiner) + "\n" + indent.prev;
|
||
}
|
||
function arrObjKeys(obj, inspect3) {
|
||
var isArr = isArray(obj);
|
||
var xs = [];
|
||
if (isArr) {
|
||
xs.length = obj.length;
|
||
for (var i = 0; i < obj.length; i++) xs[i] = has(obj, i) ? inspect3(obj[i], obj) : "";
|
||
}
|
||
var syms = typeof gOPS === "function" ? gOPS(obj) : [];
|
||
var symMap;
|
||
if (hasShammedSymbols) {
|
||
symMap = {};
|
||
for (var k = 0; k < syms.length; k++) symMap["$" + syms[k]] = syms[k];
|
||
}
|
||
for (var key in obj) {
|
||
if (!has(obj, key)) continue;
|
||
if (isArr && String(Number(key)) === key && key < obj.length) continue;
|
||
if (hasShammedSymbols && symMap["$" + key] instanceof Symbol) continue;
|
||
else if ($test.call(/[^\w$]/, key)) xs.push(inspect3(key, obj) + ": " + inspect3(obj[key], obj));
|
||
else xs.push(key + ": " + inspect3(obj[key], obj));
|
||
}
|
||
if (typeof gOPS === "function") {
|
||
for (var j = 0; j < syms.length; j++) if (isEnumerable.call(obj, syms[j])) xs.push("[" + inspect3(syms[j]) + "]: " + inspect3(obj[syms[j]], obj));
|
||
}
|
||
return xs;
|
||
}
|
||
} });
|
||
var TimeDuration = class _TimeDuration {
|
||
__time_duration_micros__;
|
||
static MICROS_PER_MILLIS = 1000n;
|
||
/**
|
||
* Get the algebraic type representation of the {@link TimeDuration} type.
|
||
* @returns The algebraic type representation of the type.
|
||
*/
|
||
static getAlgebraicType() {
|
||
return AlgebraicType.Product({ elements: [{
|
||
name: "__time_duration_micros__",
|
||
algebraicType: AlgebraicType.I64
|
||
}] });
|
||
}
|
||
static isTimeDuration(algebraicType) {
|
||
if (algebraicType.tag !== "Product") return false;
|
||
const elements = algebraicType.value.elements;
|
||
if (elements.length !== 1) return false;
|
||
const microsElement = elements[0];
|
||
return microsElement.name === "__time_duration_micros__" && microsElement.algebraicType.tag === "I64";
|
||
}
|
||
get micros() {
|
||
return this.__time_duration_micros__;
|
||
}
|
||
get millis() {
|
||
return Number(this.micros / _TimeDuration.MICROS_PER_MILLIS);
|
||
}
|
||
constructor(micros) {
|
||
this.__time_duration_micros__ = micros;
|
||
}
|
||
static fromMillis(millis) {
|
||
return new _TimeDuration(BigInt(millis) * _TimeDuration.MICROS_PER_MILLIS);
|
||
}
|
||
/** This outputs the same string format that we use in the host and in Rust modules */
|
||
toString() {
|
||
const micros = this.micros;
|
||
const sign = micros < 0 ? "-" : "+";
|
||
const pos = micros < 0 ? -micros : micros;
|
||
const secs = pos / 1000000n;
|
||
const micros_remaining = pos % 1000000n;
|
||
return `${sign}${secs}.${String(micros_remaining).padStart(6, "0")}`;
|
||
}
|
||
};
|
||
var Timestamp = class _Timestamp {
|
||
__timestamp_micros_since_unix_epoch__;
|
||
static MICROS_PER_MILLIS = 1000n;
|
||
get microsSinceUnixEpoch() {
|
||
return this.__timestamp_micros_since_unix_epoch__;
|
||
}
|
||
constructor(micros) {
|
||
this.__timestamp_micros_since_unix_epoch__ = micros;
|
||
}
|
||
/**
|
||
* Get the algebraic type representation of the {@link Timestamp} type.
|
||
* @returns The algebraic type representation of the type.
|
||
*/
|
||
static getAlgebraicType() {
|
||
return AlgebraicType.Product({ elements: [{
|
||
name: "__timestamp_micros_since_unix_epoch__",
|
||
algebraicType: AlgebraicType.I64
|
||
}] });
|
||
}
|
||
static isTimestamp(algebraicType) {
|
||
if (algebraicType.tag !== "Product") return false;
|
||
const elements = algebraicType.value.elements;
|
||
if (elements.length !== 1) return false;
|
||
const microsElement = elements[0];
|
||
return microsElement.name === "__timestamp_micros_since_unix_epoch__" && microsElement.algebraicType.tag === "I64";
|
||
}
|
||
/**
|
||
* The Unix epoch, the midnight at the beginning of January 1, 1970, UTC.
|
||
*/
|
||
static UNIX_EPOCH = new _Timestamp(0n);
|
||
/**
|
||
* Get a `Timestamp` representing the execution environment's belief of the current moment in time.
|
||
*/
|
||
static now() {
|
||
return _Timestamp.fromDate(/* @__PURE__ */ new Date());
|
||
}
|
||
/** Convert to milliseconds since Unix epoch. */
|
||
toMillis() {
|
||
return this.microsSinceUnixEpoch / 1000n;
|
||
}
|
||
/**
|
||
* Get a `Timestamp` representing the same point in time as `date`.
|
||
*/
|
||
static fromDate(date) {
|
||
const millis = date.getTime();
|
||
return new _Timestamp(BigInt(millis) * _Timestamp.MICROS_PER_MILLIS);
|
||
}
|
||
/**
|
||
* Get a `Date` representing approximately the same point in time as `this`.
|
||
*
|
||
* This method truncates to millisecond precision,
|
||
* and throws `RangeError` if the `Timestamp` is outside the range representable as a `Date`.
|
||
*/
|
||
toDate() {
|
||
const millis = this.__timestamp_micros_since_unix_epoch__ / _Timestamp.MICROS_PER_MILLIS;
|
||
if (millis > BigInt(Number.MAX_SAFE_INTEGER) || millis < BigInt(Number.MIN_SAFE_INTEGER)) throw new RangeError("Timestamp is outside of the representable range of JS's Date");
|
||
return new Date(Number(millis));
|
||
}
|
||
/**
|
||
* Get an ISO 8601 / RFC 3339 formatted string representation of this timestamp with microsecond precision.
|
||
*
|
||
* This method preserves the full microsecond precision of the timestamp,
|
||
* and throws `RangeError` if the `Timestamp` is outside the range representable in ISO format.
|
||
*
|
||
* @returns ISO 8601 formatted string with microsecond precision (e.g., '2025-02-17T10:30:45.123456Z')
|
||
*/
|
||
toISOString() {
|
||
const micros = this.__timestamp_micros_since_unix_epoch__;
|
||
const millis = micros / _Timestamp.MICROS_PER_MILLIS;
|
||
if (millis > BigInt(Number.MAX_SAFE_INTEGER) || millis < BigInt(Number.MIN_SAFE_INTEGER)) throw new RangeError("Timestamp is outside of the representable range for ISO string formatting");
|
||
const isoBase = new Date(Number(millis)).toISOString();
|
||
const microsRemainder = Math.abs(Number(micros % 1000000n));
|
||
const fractionalPart = String(microsRemainder).padStart(6, "0");
|
||
return isoBase.replace(/\.\d{3}Z$/, `.${fractionalPart}Z`);
|
||
}
|
||
since(other) {
|
||
return new TimeDuration(this.__timestamp_micros_since_unix_epoch__ - other.__timestamp_micros_since_unix_epoch__);
|
||
}
|
||
};
|
||
var Uuid = class _Uuid {
|
||
__uuid__;
|
||
/**
|
||
* The nil UUID (all zeros).
|
||
*
|
||
* @example
|
||
* ```ts
|
||
* const uuid = Uuid.NIL;
|
||
* console.assert(
|
||
* uuid.toString() === "00000000-0000-0000-0000-000000000000"
|
||
* );
|
||
* ```
|
||
*/
|
||
static NIL = new _Uuid(0n);
|
||
static MAX_UUID_BIGINT = 340282366920938463463374607431768211455n;
|
||
/**
|
||
* The max UUID (all ones).
|
||
*
|
||
* @example
|
||
* ```ts
|
||
* const uuid = Uuid.MAX;
|
||
* console.assert(
|
||
* uuid.toString() === "ffffffff-ffff-ffff-ffff-ffffffffffff"
|
||
* );
|
||
* ```
|
||
*/
|
||
static MAX = new _Uuid(_Uuid.MAX_UUID_BIGINT);
|
||
/**
|
||
* Create a UUID from a raw 128-bit value.
|
||
*
|
||
* @param u - Unsigned 128-bit integer
|
||
* @throws {Error} If the value is outside the valid UUID range
|
||
*/
|
||
constructor(u) {
|
||
if (u < 0n || u > _Uuid.MAX_UUID_BIGINT) throw new Error("Invalid UUID: must be between 0 and `MAX_UUID_BIGINT`");
|
||
this.__uuid__ = u;
|
||
}
|
||
/**
|
||
* Create a UUID `v4` from explicit random bytes.
|
||
*
|
||
* This method assumes the bytes are already sufficiently random.
|
||
* It only sets the appropriate bits for the UUID version and variant.
|
||
*
|
||
* @param bytes - Exactly 16 random bytes
|
||
* @returns A UUID `v4`
|
||
* @throws {Error} If `bytes.length !== 16`
|
||
*
|
||
* @example
|
||
* ```ts
|
||
* const randomBytes = new Uint8Array(16);
|
||
* const uuid = Uuid.fromRandomBytesV4(randomBytes);
|
||
*
|
||
* console.assert(
|
||
* uuid.toString() === "00000000-0000-4000-8000-000000000000"
|
||
* );
|
||
* ```
|
||
*/
|
||
static fromRandomBytesV4(bytes) {
|
||
if (bytes.length !== 16) throw new Error("UUID v4 requires 16 bytes");
|
||
const arr = new Uint8Array(bytes);
|
||
arr[6] = arr[6] & 15 | 64;
|
||
arr[8] = arr[8] & 63 | 128;
|
||
return new _Uuid(_Uuid.bytesToBigInt(arr));
|
||
}
|
||
/**
|
||
* Generate a UUID `v7` using a monotonic counter from `0` to `2^31 - 1`,
|
||
* a timestamp, and 4 random bytes.
|
||
*
|
||
* The counter wraps around on overflow.
|
||
*
|
||
* The UUID `v7` is structured as follows:
|
||
*
|
||
* ```ascii
|
||
* ┌───────────────────────────────────────────────┬───────────────────┐
|
||
* | B0 | B1 | B2 | B3 | B4 | B5 | B6 |
|
||
* ├───────────────────────────────────────────────┼───────────────────┤
|
||
* | unix_ts_ms | version 7 |
|
||
* └───────────────────────────────────────────────┴───────────────────┘
|
||
* ┌──────────────┬─────────┬──────────────────┬───────────────────────┐
|
||
* | B7 | B8 | B9 | B10 | B11 | B12 | B13 | B14 | B15 |
|
||
* ├──────────────┼─────────┼──────────────────┼───────────────────────┤
|
||
* | counter_high | variant | counter_low | random |
|
||
* └──────────────┴─────────┴──────────────────┴───────────────────────┘
|
||
* ```
|
||
*
|
||
* @param counter - Mutable monotonic counter (31-bit)
|
||
* @param now - Timestamp since the Unix epoch
|
||
* @param randomBytes - Exactly 4 random bytes
|
||
* @returns A UUID `v7`
|
||
*
|
||
* @throws {Error} If the `counter` is negative
|
||
* @throws {Error} If the `timestamp` is before the Unix epoch
|
||
* @throws {Error} If `randomBytes.length !== 4`
|
||
*
|
||
* @example
|
||
* ```ts
|
||
* const now = Timestamp.fromMillis(1_686_000_000_000n);
|
||
* const counter = { value: 1 };
|
||
* const randomBytes = new Uint8Array(4);
|
||
*
|
||
* const uuid = Uuid.fromCounterV7(counter, now, randomBytes);
|
||
*
|
||
* console.assert(
|
||
* uuid.toString() === "0000647e-5180-7000-8000-000200000000"
|
||
* );
|
||
* ```
|
||
*/
|
||
static fromCounterV7(counter, now, randomBytes) {
|
||
if (randomBytes.length !== 4) throw new Error("`fromCounterV7` requires `randomBytes.length == 4`");
|
||
if (counter.value < 0) throw new Error("`fromCounterV7` uuid `counter` must be non-negative");
|
||
if (now.__timestamp_micros_since_unix_epoch__ < 0) throw new Error("`fromCounterV7` `timestamp` before unix epoch");
|
||
const counterVal = counter.value;
|
||
counter.value = counterVal + 1 & 2147483647;
|
||
const tsMs = now.toMillis() & 281474976710655n;
|
||
const bytes = new Uint8Array(16);
|
||
bytes[0] = Number(tsMs >> 40n & 255n);
|
||
bytes[1] = Number(tsMs >> 32n & 255n);
|
||
bytes[2] = Number(tsMs >> 24n & 255n);
|
||
bytes[3] = Number(tsMs >> 16n & 255n);
|
||
bytes[4] = Number(tsMs >> 8n & 255n);
|
||
bytes[5] = Number(tsMs & 255n);
|
||
bytes[7] = counterVal >>> 23 & 255;
|
||
bytes[9] = counterVal >>> 15 & 255;
|
||
bytes[10] = counterVal >>> 7 & 255;
|
||
bytes[11] = (counterVal & 127) << 1 & 255;
|
||
bytes[12] |= randomBytes[0] & 127;
|
||
bytes[13] = randomBytes[1];
|
||
bytes[14] = randomBytes[2];
|
||
bytes[15] = randomBytes[3];
|
||
bytes[6] = bytes[6] & 15 | 112;
|
||
bytes[8] = bytes[8] & 63 | 128;
|
||
return new _Uuid(_Uuid.bytesToBigInt(bytes));
|
||
}
|
||
/**
|
||
* Parse a UUID from a string representation.
|
||
*
|
||
* @param s - UUID string
|
||
* @returns Parsed UUID
|
||
* @throws {Error} If the string is not a valid UUID
|
||
*
|
||
* @example
|
||
* ```ts
|
||
* const s = "01888d6e-5c00-7000-8000-000000000000";
|
||
* const uuid = Uuid.parse(s);
|
||
*
|
||
* console.assert(uuid.toString() === s);
|
||
* ```
|
||
*/
|
||
static parse(s) {
|
||
const hex = s.replace(/-/g, "");
|
||
if (hex.length !== 32) throw new Error("Invalid hex UUID");
|
||
let v = 0n;
|
||
for (let i = 0; i < 32; i += 2) v = v << 8n | BigInt(parseInt(hex.slice(i, i + 2), 16));
|
||
return new _Uuid(v);
|
||
}
|
||
/** Convert to string (hyphenated form). */
|
||
toString() {
|
||
const hex = [..._Uuid.bigIntToBytes(this.__uuid__)].map((b) => b.toString(16).padStart(2, "0")).join("");
|
||
return hex.slice(0, 8) + "-" + hex.slice(8, 12) + "-" + hex.slice(12, 16) + "-" + hex.slice(16, 20) + "-" + hex.slice(20);
|
||
}
|
||
/** Convert to bigint (u128). */
|
||
asBigInt() {
|
||
return this.__uuid__;
|
||
}
|
||
/** Return a `Uint8Array` of 16 bytes. */
|
||
toBytes() {
|
||
return _Uuid.bigIntToBytes(this.__uuid__);
|
||
}
|
||
static bytesToBigInt(bytes) {
|
||
let result = 0n;
|
||
for (const b of bytes) result = result << 8n | BigInt(b);
|
||
return result;
|
||
}
|
||
static bigIntToBytes(value) {
|
||
const bytes = new Uint8Array(16);
|
||
for (let i = 15; i >= 0; i--) {
|
||
bytes[i] = Number(value & 255n);
|
||
value >>= 8n;
|
||
}
|
||
return bytes;
|
||
}
|
||
/**
|
||
* Returns the version of this UUID.
|
||
*
|
||
* This represents the algorithm used to generate the value.
|
||
*
|
||
* @returns A `UuidVersion`
|
||
* @throws {Error} If the version field is not recognized
|
||
*/
|
||
getVersion() {
|
||
const version = this.toBytes()[6] >> 4 & 15;
|
||
switch (version) {
|
||
case 4: return "V4";
|
||
case 7: return "V7";
|
||
default:
|
||
if (this == _Uuid.NIL) return "Nil";
|
||
if (this == _Uuid.MAX) return "Max";
|
||
throw new Error(`Unsupported UUID version: ${version}`);
|
||
}
|
||
}
|
||
/**
|
||
* Extract the monotonic counter from a UUIDv7.
|
||
*
|
||
* Intended for testing and diagnostics.
|
||
* Behavior is undefined if called on a non-V7 UUID.
|
||
*
|
||
* @returns 31-bit counter value
|
||
*/
|
||
getCounter() {
|
||
const bytes = this.toBytes();
|
||
const high = bytes[7];
|
||
const mid1 = bytes[9];
|
||
const mid2 = bytes[10];
|
||
const low = bytes[11] >>> 1;
|
||
return high << 23 | mid1 << 15 | mid2 << 7 | low | 0;
|
||
}
|
||
compareTo(other) {
|
||
if (this.__uuid__ < other.__uuid__) return -1;
|
||
if (this.__uuid__ > other.__uuid__) return 1;
|
||
return 0;
|
||
}
|
||
static getAlgebraicType() {
|
||
return AlgebraicType.Product({ elements: [{
|
||
name: "__uuid__",
|
||
algebraicType: AlgebraicType.U128
|
||
}] });
|
||
}
|
||
};
|
||
var BinaryReader = class {
|
||
/**
|
||
* The DataView used to read values from the binary data.
|
||
*
|
||
* Note: The DataView's `byteOffset` is relative to the beginning of the
|
||
* underlying ArrayBuffer, not the start of the provided Uint8Array input.
|
||
* This `BinaryReader`'s `#offset` field is used to track the current read position
|
||
* relative to the start of the provided Uint8Array input.
|
||
*/
|
||
view;
|
||
/**
|
||
* Represents the offset (in bytes) relative to the start of the DataView
|
||
* and provided Uint8Array input.
|
||
*
|
||
* Note: This is *not* the absolute byte offset within the underlying ArrayBuffer.
|
||
*/
|
||
offset = 0;
|
||
constructor(input) {
|
||
this.view = input instanceof DataView ? input : new DataView(input.buffer, input.byteOffset, input.byteLength);
|
||
this.offset = 0;
|
||
}
|
||
reset(view) {
|
||
this.view = view;
|
||
this.offset = 0;
|
||
}
|
||
get remaining() {
|
||
return this.view.byteLength - this.offset;
|
||
}
|
||
/** Ensure we have at least `n` bytes left to read */
|
||
#ensure(n) {
|
||
if (this.offset + n > this.view.byteLength) throw new RangeError(`Tried to read ${n} byte(s) at relative offset ${this.offset}, but only ${this.remaining} byte(s) remain`);
|
||
}
|
||
readUInt8Array() {
|
||
const length = this.readU32();
|
||
this.#ensure(length);
|
||
return this.readBytes(length);
|
||
}
|
||
readBool() {
|
||
const value = this.view.getUint8(this.offset);
|
||
this.offset += 1;
|
||
return value !== 0;
|
||
}
|
||
readByte() {
|
||
const value = this.view.getUint8(this.offset);
|
||
this.offset += 1;
|
||
return value;
|
||
}
|
||
readBytes(length) {
|
||
const array = new Uint8Array(this.view.buffer, this.view.byteOffset + this.offset, length);
|
||
this.offset += length;
|
||
return array;
|
||
}
|
||
readI8() {
|
||
const value = this.view.getInt8(this.offset);
|
||
this.offset += 1;
|
||
return value;
|
||
}
|
||
readU8() {
|
||
return this.readByte();
|
||
}
|
||
readI16() {
|
||
const value = this.view.getInt16(this.offset, true);
|
||
this.offset += 2;
|
||
return value;
|
||
}
|
||
readU16() {
|
||
const value = this.view.getUint16(this.offset, true);
|
||
this.offset += 2;
|
||
return value;
|
||
}
|
||
readI32() {
|
||
const value = this.view.getInt32(this.offset, true);
|
||
this.offset += 4;
|
||
return value;
|
||
}
|
||
readU32() {
|
||
const value = this.view.getUint32(this.offset, true);
|
||
this.offset += 4;
|
||
return value;
|
||
}
|
||
readI64() {
|
||
const value = this.view.getBigInt64(this.offset, true);
|
||
this.offset += 8;
|
||
return value;
|
||
}
|
||
readU64() {
|
||
const value = this.view.getBigUint64(this.offset, true);
|
||
this.offset += 8;
|
||
return value;
|
||
}
|
||
readU128() {
|
||
const lowerPart = this.view.getBigUint64(this.offset, true);
|
||
const upperPart = this.view.getBigUint64(this.offset + 8, true);
|
||
this.offset += 16;
|
||
return (upperPart << BigInt(64)) + lowerPart;
|
||
}
|
||
readI128() {
|
||
const lowerPart = this.view.getBigUint64(this.offset, true);
|
||
const upperPart = this.view.getBigInt64(this.offset + 8, true);
|
||
this.offset += 16;
|
||
return (upperPart << BigInt(64)) + lowerPart;
|
||
}
|
||
readU256() {
|
||
const p0 = this.view.getBigUint64(this.offset, true);
|
||
const p1 = this.view.getBigUint64(this.offset + 8, true);
|
||
const p2 = this.view.getBigUint64(this.offset + 16, true);
|
||
const p3 = this.view.getBigUint64(this.offset + 24, true);
|
||
this.offset += 32;
|
||
return (p3 << BigInt(192)) + (p2 << BigInt(128)) + (p1 << BigInt(64)) + p0;
|
||
}
|
||
readI256() {
|
||
const p0 = this.view.getBigUint64(this.offset, true);
|
||
const p1 = this.view.getBigUint64(this.offset + 8, true);
|
||
const p2 = this.view.getBigUint64(this.offset + 16, true);
|
||
const p3 = this.view.getBigInt64(this.offset + 24, true);
|
||
this.offset += 32;
|
||
return (p3 << BigInt(192)) + (p2 << BigInt(128)) + (p1 << BigInt(64)) + p0;
|
||
}
|
||
readF32() {
|
||
const value = this.view.getFloat32(this.offset, true);
|
||
this.offset += 4;
|
||
return value;
|
||
}
|
||
readF64() {
|
||
const value = this.view.getFloat64(this.offset, true);
|
||
this.offset += 8;
|
||
return value;
|
||
}
|
||
readString() {
|
||
const uint8Array = this.readUInt8Array();
|
||
return new TextDecoder("utf-8").decode(uint8Array);
|
||
}
|
||
};
|
||
var import_base64_js = __toESM(require_base64_js());
|
||
var ArrayBufferPrototypeTransfer = ArrayBuffer.prototype.transfer ?? function(newByteLength) {
|
||
if (newByteLength === void 0) return this.slice();
|
||
else if (newByteLength <= this.byteLength) return this.slice(0, newByteLength);
|
||
else {
|
||
const copy = new Uint8Array(newByteLength);
|
||
copy.set(new Uint8Array(this));
|
||
return copy.buffer;
|
||
}
|
||
};
|
||
var ResizableBuffer = class {
|
||
buffer;
|
||
view;
|
||
constructor(init) {
|
||
this.buffer = typeof init === "number" ? new ArrayBuffer(init) : init;
|
||
this.view = new DataView(this.buffer);
|
||
}
|
||
get capacity() {
|
||
return this.buffer.byteLength;
|
||
}
|
||
grow(newSize) {
|
||
if (newSize <= this.buffer.byteLength) return;
|
||
this.buffer = ArrayBufferPrototypeTransfer.call(this.buffer, newSize);
|
||
this.view = new DataView(this.buffer);
|
||
}
|
||
};
|
||
var BinaryWriter = class {
|
||
buffer;
|
||
offset = 0;
|
||
constructor(init) {
|
||
this.buffer = typeof init === "number" ? new ResizableBuffer(init) : init;
|
||
}
|
||
clear() {
|
||
this.offset = 0;
|
||
}
|
||
reset(buffer) {
|
||
this.buffer = buffer;
|
||
this.offset = 0;
|
||
}
|
||
expandBuffer(additionalCapacity) {
|
||
const minCapacity = this.offset + additionalCapacity + 1;
|
||
if (minCapacity <= this.buffer.capacity) return;
|
||
let newCapacity = this.buffer.capacity * 2;
|
||
if (newCapacity < minCapacity) newCapacity = minCapacity;
|
||
this.buffer.grow(newCapacity);
|
||
}
|
||
toBase64() {
|
||
return (0, import_base64_js.fromByteArray)(this.getBuffer());
|
||
}
|
||
getBuffer() {
|
||
return new Uint8Array(this.buffer.buffer, 0, this.offset);
|
||
}
|
||
get view() {
|
||
return this.buffer.view;
|
||
}
|
||
writeUInt8Array(value) {
|
||
const length = value.length;
|
||
this.expandBuffer(4 + length);
|
||
this.writeU32(length);
|
||
new Uint8Array(this.buffer.buffer, this.offset).set(value);
|
||
this.offset += length;
|
||
}
|
||
writeBool(value) {
|
||
this.expandBuffer(1);
|
||
this.view.setUint8(this.offset, value ? 1 : 0);
|
||
this.offset += 1;
|
||
}
|
||
writeByte(value) {
|
||
this.expandBuffer(1);
|
||
this.view.setUint8(this.offset, value);
|
||
this.offset += 1;
|
||
}
|
||
writeI8(value) {
|
||
this.expandBuffer(1);
|
||
this.view.setInt8(this.offset, value);
|
||
this.offset += 1;
|
||
}
|
||
writeU8(value) {
|
||
this.expandBuffer(1);
|
||
this.view.setUint8(this.offset, value);
|
||
this.offset += 1;
|
||
}
|
||
writeI16(value) {
|
||
this.expandBuffer(2);
|
||
this.view.setInt16(this.offset, value, true);
|
||
this.offset += 2;
|
||
}
|
||
writeU16(value) {
|
||
this.expandBuffer(2);
|
||
this.view.setUint16(this.offset, value, true);
|
||
this.offset += 2;
|
||
}
|
||
writeI32(value) {
|
||
this.expandBuffer(4);
|
||
this.view.setInt32(this.offset, value, true);
|
||
this.offset += 4;
|
||
}
|
||
writeU32(value) {
|
||
this.expandBuffer(4);
|
||
this.view.setUint32(this.offset, value, true);
|
||
this.offset += 4;
|
||
}
|
||
writeI64(value) {
|
||
this.expandBuffer(8);
|
||
this.view.setBigInt64(this.offset, value, true);
|
||
this.offset += 8;
|
||
}
|
||
writeU64(value) {
|
||
this.expandBuffer(8);
|
||
this.view.setBigUint64(this.offset, value, true);
|
||
this.offset += 8;
|
||
}
|
||
writeU128(value) {
|
||
this.expandBuffer(16);
|
||
const lowerPart = value & BigInt("0xFFFFFFFFFFFFFFFF");
|
||
const upperPart = value >> BigInt(64);
|
||
this.view.setBigUint64(this.offset, lowerPart, true);
|
||
this.view.setBigUint64(this.offset + 8, upperPart, true);
|
||
this.offset += 16;
|
||
}
|
||
writeI128(value) {
|
||
this.expandBuffer(16);
|
||
const lowerPart = value & BigInt("0xFFFFFFFFFFFFFFFF");
|
||
const upperPart = value >> BigInt(64);
|
||
this.view.setBigInt64(this.offset, lowerPart, true);
|
||
this.view.setBigInt64(this.offset + 8, upperPart, true);
|
||
this.offset += 16;
|
||
}
|
||
writeU256(value) {
|
||
this.expandBuffer(32);
|
||
const low_64_mask = BigInt("0xFFFFFFFFFFFFFFFF");
|
||
const p0 = value & low_64_mask;
|
||
const p1 = value >> BigInt(64) & low_64_mask;
|
||
const p2 = value >> BigInt(128) & low_64_mask;
|
||
const p3 = value >> BigInt(192);
|
||
this.view.setBigUint64(this.offset + 0, p0, true);
|
||
this.view.setBigUint64(this.offset + 8, p1, true);
|
||
this.view.setBigUint64(this.offset + 16, p2, true);
|
||
this.view.setBigUint64(this.offset + 24, p3, true);
|
||
this.offset += 32;
|
||
}
|
||
writeI256(value) {
|
||
this.expandBuffer(32);
|
||
const low_64_mask = BigInt("0xFFFFFFFFFFFFFFFF");
|
||
const p0 = value & low_64_mask;
|
||
const p1 = value >> BigInt(64) & low_64_mask;
|
||
const p2 = value >> BigInt(128) & low_64_mask;
|
||
const p3 = value >> BigInt(192);
|
||
this.view.setBigUint64(this.offset + 0, p0, true);
|
||
this.view.setBigUint64(this.offset + 8, p1, true);
|
||
this.view.setBigUint64(this.offset + 16, p2, true);
|
||
this.view.setBigInt64(this.offset + 24, p3, true);
|
||
this.offset += 32;
|
||
}
|
||
writeF32(value) {
|
||
this.expandBuffer(4);
|
||
this.view.setFloat32(this.offset, value, true);
|
||
this.offset += 4;
|
||
}
|
||
writeF64(value) {
|
||
this.expandBuffer(8);
|
||
this.view.setFloat64(this.offset, value, true);
|
||
this.offset += 8;
|
||
}
|
||
writeString(value) {
|
||
const encodedString = new TextEncoder().encode(value);
|
||
this.writeUInt8Array(encodedString);
|
||
}
|
||
};
|
||
function uint8ArrayToHexString(array) {
|
||
return Array.prototype.map.call(array.reverse(), (x) => ("00" + x.toString(16)).slice(-2)).join("");
|
||
}
|
||
function uint8ArrayToU128(array) {
|
||
if (array.length != 16) throw new Error(`Uint8Array is not 16 bytes long: ${array}`);
|
||
return new BinaryReader(array).readU128();
|
||
}
|
||
function uint8ArrayToU256(array) {
|
||
if (array.length != 32) throw new Error(`Uint8Array is not 32 bytes long: [${array}]`);
|
||
return new BinaryReader(array).readU256();
|
||
}
|
||
function hexStringToUint8Array(str) {
|
||
if (str.startsWith("0x")) str = str.slice(2);
|
||
const matches = str.match(/.{1,2}/g) || [];
|
||
return Uint8Array.from(matches.map((byte) => parseInt(byte, 16))).reverse();
|
||
}
|
||
function hexStringToU128(str) {
|
||
return uint8ArrayToU128(hexStringToUint8Array(str));
|
||
}
|
||
function hexStringToU256(str) {
|
||
return uint8ArrayToU256(hexStringToUint8Array(str));
|
||
}
|
||
function u128ToUint8Array(data) {
|
||
const writer = new BinaryWriter(16);
|
||
writer.writeU128(data);
|
||
return writer.getBuffer();
|
||
}
|
||
function u128ToHexString(data) {
|
||
return uint8ArrayToHexString(u128ToUint8Array(data));
|
||
}
|
||
function u256ToUint8Array(data) {
|
||
const writer = new BinaryWriter(32);
|
||
writer.writeU256(data);
|
||
return writer.getBuffer();
|
||
}
|
||
function u256ToHexString(data) {
|
||
return uint8ArrayToHexString(u256ToUint8Array(data));
|
||
}
|
||
function toPascalCase(s) {
|
||
const str = toCamelCase(s);
|
||
return str.charAt(0).toUpperCase() + str.slice(1);
|
||
}
|
||
function toCamelCase(s) {
|
||
const str = s.replace(/[-_]+/g, "_").replace(/_([a-zA-Z0-9])/g, (_, c) => c.toUpperCase());
|
||
return str.charAt(0).toLowerCase() + str.slice(1);
|
||
}
|
||
function bsatnBaseSize(typespace, ty) {
|
||
const assumedArrayLength = 4;
|
||
while (ty.tag === "Ref") ty = typespace.types[ty.value];
|
||
if (ty.tag === "Product") {
|
||
let sum = 0;
|
||
for (const { algebraicType: elem } of ty.value.elements) sum += bsatnBaseSize(typespace, elem);
|
||
return sum;
|
||
} else if (ty.tag === "Sum") {
|
||
let min = Infinity;
|
||
for (const { algebraicType: vari } of ty.value.variants) {
|
||
const vSize = bsatnBaseSize(typespace, vari);
|
||
if (vSize < min) min = vSize;
|
||
}
|
||
if (min === Infinity) min = 0;
|
||
return 4 + min;
|
||
} else if (ty.tag == "Array") return 4 + assumedArrayLength * bsatnBaseSize(typespace, ty.value);
|
||
return {
|
||
String: 4 + assumedArrayLength,
|
||
Sum: 1,
|
||
Bool: 1,
|
||
I8: 1,
|
||
U8: 1,
|
||
I16: 2,
|
||
U16: 2,
|
||
I32: 4,
|
||
U32: 4,
|
||
F32: 4,
|
||
I64: 8,
|
||
U64: 8,
|
||
F64: 8,
|
||
I128: 16,
|
||
U128: 16,
|
||
I256: 32,
|
||
U256: 32
|
||
}[ty.tag];
|
||
}
|
||
var hasOwn = Object.hasOwn;
|
||
var ConnectionId = class _ConnectionId {
|
||
__connection_id__;
|
||
/**
|
||
* Creates a new `ConnectionId`.
|
||
*/
|
||
constructor(data) {
|
||
this.__connection_id__ = data;
|
||
}
|
||
/**
|
||
* Get the algebraic type representation of the {@link ConnectionId} type.
|
||
* @returns The algebraic type representation of the type.
|
||
*/
|
||
static getAlgebraicType() {
|
||
return AlgebraicType.Product({ elements: [{
|
||
name: "__connection_id__",
|
||
algebraicType: AlgebraicType.U128
|
||
}] });
|
||
}
|
||
isZero() {
|
||
return this.__connection_id__ === BigInt(0);
|
||
}
|
||
static nullIfZero(addr) {
|
||
if (addr.isZero()) return null;
|
||
else return addr;
|
||
}
|
||
static random() {
|
||
function randomU8() {
|
||
return Math.floor(Math.random() * 255);
|
||
}
|
||
let result = BigInt(0);
|
||
for (let i = 0; i < 16; i++) result = result << BigInt(8) | BigInt(randomU8());
|
||
return new _ConnectionId(result);
|
||
}
|
||
/**
|
||
* Compare two connection IDs for equality.
|
||
*/
|
||
isEqual(other) {
|
||
return this.__connection_id__ == other.__connection_id__;
|
||
}
|
||
/**
|
||
* Check if two connection IDs are equal.
|
||
*/
|
||
equals(other) {
|
||
return this.isEqual(other);
|
||
}
|
||
/**
|
||
* Print the connection ID as a hexadecimal string.
|
||
*/
|
||
toHexString() {
|
||
return u128ToHexString(this.__connection_id__);
|
||
}
|
||
/**
|
||
* Convert the connection ID to a Uint8Array.
|
||
*/
|
||
toUint8Array() {
|
||
return u128ToUint8Array(this.__connection_id__);
|
||
}
|
||
/**
|
||
* Parse a connection ID from a hexadecimal string.
|
||
*/
|
||
static fromString(str) {
|
||
return new _ConnectionId(hexStringToU128(str));
|
||
}
|
||
static fromStringOrNull(str) {
|
||
const addr = _ConnectionId.fromString(str);
|
||
if (addr.isZero()) return null;
|
||
else return addr;
|
||
}
|
||
};
|
||
var Identity = class _Identity {
|
||
__identity__;
|
||
/**
|
||
* Creates a new `Identity`.
|
||
*
|
||
* `data` can be a hexadecimal string or a `bigint`.
|
||
*/
|
||
constructor(data) {
|
||
this.__identity__ = typeof data === "string" ? hexStringToU256(data) : data;
|
||
}
|
||
/**
|
||
* Get the algebraic type representation of the {@link Identity} type.
|
||
* @returns The algebraic type representation of the type.
|
||
*/
|
||
static getAlgebraicType() {
|
||
return AlgebraicType.Product({ elements: [{
|
||
name: "__identity__",
|
||
algebraicType: AlgebraicType.U256
|
||
}] });
|
||
}
|
||
/**
|
||
* Check if two identities are equal.
|
||
*/
|
||
isEqual(other) {
|
||
return this.toHexString() === other.toHexString();
|
||
}
|
||
/**
|
||
* Check if two identities are equal.
|
||
*/
|
||
equals(other) {
|
||
return this.isEqual(other);
|
||
}
|
||
/**
|
||
* Print the identity as a hexadecimal string.
|
||
*/
|
||
toHexString() {
|
||
return u256ToHexString(this.__identity__);
|
||
}
|
||
/**
|
||
* Convert the address to a Uint8Array.
|
||
*/
|
||
toUint8Array() {
|
||
return u256ToUint8Array(this.__identity__);
|
||
}
|
||
/**
|
||
* Parse an Identity from a hexadecimal string.
|
||
*/
|
||
static fromString(str) {
|
||
return new _Identity(str);
|
||
}
|
||
/**
|
||
* Zero identity (0x0000000000000000000000000000000000000000000000000000000000000000)
|
||
*/
|
||
static zero() {
|
||
return new _Identity(0n);
|
||
}
|
||
toString() {
|
||
return this.toHexString();
|
||
}
|
||
};
|
||
var SERIALIZERS = /* @__PURE__ */ new Map();
|
||
var DESERIALIZERS = /* @__PURE__ */ new Map();
|
||
var AlgebraicType = {
|
||
Ref: (value) => ({
|
||
tag: "Ref",
|
||
value
|
||
}),
|
||
Sum: (value) => ({
|
||
tag: "Sum",
|
||
value
|
||
}),
|
||
Product: (value) => ({
|
||
tag: "Product",
|
||
value
|
||
}),
|
||
Array: (value) => ({
|
||
tag: "Array",
|
||
value
|
||
}),
|
||
String: { tag: "String" },
|
||
Bool: { tag: "Bool" },
|
||
I8: { tag: "I8" },
|
||
U8: { tag: "U8" },
|
||
I16: { tag: "I16" },
|
||
U16: { tag: "U16" },
|
||
I32: { tag: "I32" },
|
||
U32: { tag: "U32" },
|
||
I64: { tag: "I64" },
|
||
U64: { tag: "U64" },
|
||
I128: { tag: "I128" },
|
||
U128: { tag: "U128" },
|
||
I256: { tag: "I256" },
|
||
U256: { tag: "U256" },
|
||
F32: { tag: "F32" },
|
||
F64: { tag: "F64" },
|
||
makeSerializer(ty, typespace) {
|
||
if (ty.tag === "Ref") {
|
||
if (!typespace) throw new Error("cannot serialize refs without a typespace");
|
||
while (ty.tag === "Ref") ty = typespace.types[ty.value];
|
||
}
|
||
switch (ty.tag) {
|
||
case "Product": return ProductType.makeSerializer(ty.value, typespace);
|
||
case "Sum": return SumType.makeSerializer(ty.value, typespace);
|
||
case "Array": if (ty.value.tag === "U8") return serializeUint8Array;
|
||
else {
|
||
const serialize = AlgebraicType.makeSerializer(ty.value, typespace);
|
||
return (writer, value) => {
|
||
writer.writeU32(value.length);
|
||
for (const elem of value) serialize(writer, elem);
|
||
};
|
||
}
|
||
default: return primitiveSerializers[ty.tag];
|
||
}
|
||
},
|
||
serializeValue(writer, ty, value, typespace) {
|
||
AlgebraicType.makeSerializer(ty, typespace)(writer, value);
|
||
},
|
||
makeDeserializer(ty, typespace) {
|
||
if (ty.tag === "Ref") {
|
||
if (!typespace) throw new Error("cannot deserialize refs without a typespace");
|
||
while (ty.tag === "Ref") ty = typespace.types[ty.value];
|
||
}
|
||
switch (ty.tag) {
|
||
case "Product": return ProductType.makeDeserializer(ty.value, typespace);
|
||
case "Sum": return SumType.makeDeserializer(ty.value, typespace);
|
||
case "Array": if (ty.value.tag === "U8") return deserializeUint8Array;
|
||
else {
|
||
const deserialize = AlgebraicType.makeDeserializer(ty.value, typespace);
|
||
return (reader) => {
|
||
const length = reader.readU32();
|
||
const result = Array(length);
|
||
for (let i = 0; i < length; i++) result[i] = deserialize(reader);
|
||
return result;
|
||
};
|
||
}
|
||
default: return primitiveDeserializers[ty.tag];
|
||
}
|
||
},
|
||
deserializeValue(reader, ty, typespace) {
|
||
return AlgebraicType.makeDeserializer(ty, typespace)(reader);
|
||
},
|
||
intoMapKey: function(ty, value) {
|
||
switch (ty.tag) {
|
||
case "U8":
|
||
case "U16":
|
||
case "U32":
|
||
case "U64":
|
||
case "U128":
|
||
case "U256":
|
||
case "I8":
|
||
case "I16":
|
||
case "I32":
|
||
case "I64":
|
||
case "I128":
|
||
case "I256":
|
||
case "F32":
|
||
case "F64":
|
||
case "String":
|
||
case "Bool": return value;
|
||
case "Product": return ProductType.intoMapKey(ty.value, value);
|
||
default: {
|
||
const writer = new BinaryWriter(10);
|
||
AlgebraicType.serializeValue(writer, ty, value);
|
||
return writer.toBase64();
|
||
}
|
||
}
|
||
}
|
||
};
|
||
function bindCall(f) {
|
||
return Function.prototype.call.bind(f);
|
||
}
|
||
var primitiveSerializers = {
|
||
Bool: bindCall(BinaryWriter.prototype.writeBool),
|
||
I8: bindCall(BinaryWriter.prototype.writeI8),
|
||
U8: bindCall(BinaryWriter.prototype.writeU8),
|
||
I16: bindCall(BinaryWriter.prototype.writeI16),
|
||
U16: bindCall(BinaryWriter.prototype.writeU16),
|
||
I32: bindCall(BinaryWriter.prototype.writeI32),
|
||
U32: bindCall(BinaryWriter.prototype.writeU32),
|
||
I64: bindCall(BinaryWriter.prototype.writeI64),
|
||
U64: bindCall(BinaryWriter.prototype.writeU64),
|
||
I128: bindCall(BinaryWriter.prototype.writeI128),
|
||
U128: bindCall(BinaryWriter.prototype.writeU128),
|
||
I256: bindCall(BinaryWriter.prototype.writeI256),
|
||
U256: bindCall(BinaryWriter.prototype.writeU256),
|
||
F32: bindCall(BinaryWriter.prototype.writeF32),
|
||
F64: bindCall(BinaryWriter.prototype.writeF64),
|
||
String: bindCall(BinaryWriter.prototype.writeString)
|
||
};
|
||
Object.freeze(primitiveSerializers);
|
||
var serializeUint8Array = bindCall(BinaryWriter.prototype.writeUInt8Array);
|
||
var primitiveDeserializers = {
|
||
Bool: bindCall(BinaryReader.prototype.readBool),
|
||
I8: bindCall(BinaryReader.prototype.readI8),
|
||
U8: bindCall(BinaryReader.prototype.readU8),
|
||
I16: bindCall(BinaryReader.prototype.readI16),
|
||
U16: bindCall(BinaryReader.prototype.readU16),
|
||
I32: bindCall(BinaryReader.prototype.readI32),
|
||
U32: bindCall(BinaryReader.prototype.readU32),
|
||
I64: bindCall(BinaryReader.prototype.readI64),
|
||
U64: bindCall(BinaryReader.prototype.readU64),
|
||
I128: bindCall(BinaryReader.prototype.readI128),
|
||
U128: bindCall(BinaryReader.prototype.readU128),
|
||
I256: bindCall(BinaryReader.prototype.readI256),
|
||
U256: bindCall(BinaryReader.prototype.readU256),
|
||
F32: bindCall(BinaryReader.prototype.readF32),
|
||
F64: bindCall(BinaryReader.prototype.readF64),
|
||
String: bindCall(BinaryReader.prototype.readString)
|
||
};
|
||
Object.freeze(primitiveDeserializers);
|
||
var deserializeUint8Array = bindCall(BinaryReader.prototype.readUInt8Array);
|
||
var primitiveSizes = {
|
||
Bool: 1,
|
||
I8: 1,
|
||
U8: 1,
|
||
I16: 2,
|
||
U16: 2,
|
||
I32: 4,
|
||
U32: 4,
|
||
I64: 8,
|
||
U64: 8,
|
||
I128: 16,
|
||
U128: 16,
|
||
I256: 32,
|
||
U256: 32,
|
||
F32: 4,
|
||
F64: 8
|
||
};
|
||
var fixedSizePrimitives = new Set(Object.keys(primitiveSizes));
|
||
var isFixedSizeProduct = (ty) => ty.elements.every(({ algebraicType }) => fixedSizePrimitives.has(algebraicType.tag));
|
||
var productSize = (ty) => ty.elements.reduce((acc, { algebraicType }) => acc + primitiveSizes[algebraicType.tag], 0);
|
||
var primitiveJSName = {
|
||
Bool: "Uint8",
|
||
I8: "Int8",
|
||
U8: "Uint8",
|
||
I16: "Int16",
|
||
U16: "Uint16",
|
||
I32: "Int32",
|
||
U32: "Uint32",
|
||
I64: "BigInt64",
|
||
U64: "BigUint64",
|
||
F32: "Float32",
|
||
F64: "Float64"
|
||
};
|
||
var specialProductDeserializers = {
|
||
__time_duration_micros__: (reader) => new TimeDuration(reader.readI64()),
|
||
__timestamp_micros_since_unix_epoch__: (reader) => new Timestamp(reader.readI64()),
|
||
__identity__: (reader) => new Identity(reader.readU256()),
|
||
__connection_id__: (reader) => new ConnectionId(reader.readU128()),
|
||
__uuid__: (reader) => new Uuid(reader.readU128())
|
||
};
|
||
Object.freeze(specialProductDeserializers);
|
||
var unitDeserializer = () => ({});
|
||
var getElementInitializer = (element) => {
|
||
let init;
|
||
switch (element.algebraicType.tag) {
|
||
case "String":
|
||
init = "''";
|
||
break;
|
||
case "Bool":
|
||
init = "false";
|
||
break;
|
||
case "I8":
|
||
case "U8":
|
||
case "I16":
|
||
case "U16":
|
||
case "I32":
|
||
case "U32":
|
||
init = "0";
|
||
break;
|
||
case "I64":
|
||
case "U64":
|
||
case "I128":
|
||
case "U128":
|
||
case "I256":
|
||
case "U256":
|
||
init = "0n";
|
||
break;
|
||
case "F32":
|
||
case "F64":
|
||
init = "0.0";
|
||
break;
|
||
default: init = "undefined";
|
||
}
|
||
return `${element.name}: ${init}`;
|
||
};
|
||
var ProductType = {
|
||
makeSerializer(ty, typespace) {
|
||
let serializer = SERIALIZERS.get(ty);
|
||
if (serializer != null) return serializer;
|
||
if (isFixedSizeProduct(ty)) {
|
||
const body2 = `"use strict";
|
||
writer.expandBuffer(${productSize(ty)});
|
||
const view = writer.view;
|
||
${ty.elements.map(({ name, algebraicType: { tag } }) => tag in primitiveJSName ? `view.set${primitiveJSName[tag]}(writer.offset, value.${name}, ${primitiveSizes[tag] > 1 ? "true" : ""});
|
||
writer.offset += ${primitiveSizes[tag]};` : `writer.write${tag}(value.${name});`).join("\n")}`;
|
||
serializer = Function("writer", "value", body2);
|
||
SERIALIZERS.set(ty, serializer);
|
||
return serializer;
|
||
}
|
||
const serializers = {};
|
||
const body = "\"use strict\";\n" + ty.elements.map((element) => `this.${element.name}(writer, value.${element.name});`).join("\n");
|
||
serializer = Function("writer", "value", body).bind(serializers);
|
||
SERIALIZERS.set(ty, serializer);
|
||
for (const { name, algebraicType } of ty.elements) serializers[name] = AlgebraicType.makeSerializer(algebraicType, typespace);
|
||
Object.freeze(serializers);
|
||
return serializer;
|
||
},
|
||
serializeValue(writer, ty, value, typespace) {
|
||
ProductType.makeSerializer(ty, typespace)(writer, value);
|
||
},
|
||
makeDeserializer(ty, typespace) {
|
||
switch (ty.elements.length) {
|
||
case 0: return unitDeserializer;
|
||
case 1: {
|
||
const fieldName = ty.elements[0].name;
|
||
if (hasOwn(specialProductDeserializers, fieldName)) return specialProductDeserializers[fieldName];
|
||
}
|
||
}
|
||
let deserializer = DESERIALIZERS.get(ty);
|
||
if (deserializer != null) return deserializer;
|
||
if (isFixedSizeProduct(ty)) {
|
||
const body = `"use strict";
|
||
const result = { ${ty.elements.map(getElementInitializer).join(", ")} };
|
||
const view = reader.view;
|
||
${ty.elements.map(({ name, algebraicType: { tag } }) => tag in primitiveJSName ? tag === "Bool" ? `result.${name} = view.getUint8(reader.offset) !== 0;
|
||
reader.offset += 1;` : `result.${name} = view.get${primitiveJSName[tag]}(reader.offset, ${primitiveSizes[tag] > 1 ? "true" : ""});
|
||
reader.offset += ${primitiveSizes[tag]};` : `result.${name} = reader.read${tag}();`).join("\n")}
|
||
return result;`;
|
||
deserializer = Function("reader", body);
|
||
DESERIALIZERS.set(ty, deserializer);
|
||
return deserializer;
|
||
}
|
||
const deserializers = {};
|
||
deserializer = Function("reader", `"use strict";
|
||
const result = { ${ty.elements.map(getElementInitializer).join(", ")} };
|
||
${ty.elements.map(({ name }) => `result.${name} = this.${name}(reader);`).join("\n")}
|
||
return result;`).bind(deserializers);
|
||
DESERIALIZERS.set(ty, deserializer);
|
||
for (const { name, algebraicType } of ty.elements) deserializers[name] = AlgebraicType.makeDeserializer(algebraicType, typespace);
|
||
Object.freeze(deserializers);
|
||
return deserializer;
|
||
},
|
||
deserializeValue(reader, ty, typespace) {
|
||
return ProductType.makeDeserializer(ty, typespace)(reader);
|
||
},
|
||
intoMapKey(ty, value) {
|
||
if (ty.elements.length === 1) {
|
||
const fieldName = ty.elements[0].name;
|
||
if (hasOwn(specialProductDeserializers, fieldName)) return value[fieldName];
|
||
}
|
||
const writer = new BinaryWriter(10);
|
||
AlgebraicType.serializeValue(writer, AlgebraicType.Product(ty), value);
|
||
return writer.toBase64();
|
||
}
|
||
};
|
||
var SumType = {
|
||
makeSerializer(ty, typespace) {
|
||
if (ty.variants.length == 2 && ty.variants[0].name === "some" && ty.variants[1].name === "none") {
|
||
const serialize = AlgebraicType.makeSerializer(ty.variants[0].algebraicType, typespace);
|
||
return (writer, value) => {
|
||
if (value !== null && value !== void 0) {
|
||
writer.writeByte(0);
|
||
serialize(writer, value);
|
||
} else writer.writeByte(1);
|
||
};
|
||
} else if (ty.variants.length == 2 && ty.variants[0].name === "ok" && ty.variants[1].name === "err") {
|
||
const serializeOk = AlgebraicType.makeSerializer(ty.variants[0].algebraicType, typespace);
|
||
const serializeErr = AlgebraicType.makeSerializer(ty.variants[0].algebraicType, typespace);
|
||
return (writer, value) => {
|
||
if ("ok" in value) {
|
||
writer.writeU8(0);
|
||
serializeOk(writer, value.ok);
|
||
} else if ("err" in value) {
|
||
writer.writeU8(1);
|
||
serializeErr(writer, value.err);
|
||
} else throw new TypeError("could not serialize result: object had neither a `ok` nor an `err` field");
|
||
};
|
||
} else {
|
||
let serializer = SERIALIZERS.get(ty);
|
||
if (serializer != null) return serializer;
|
||
const serializers = {};
|
||
const body = `switch (value.tag) {
|
||
${ty.variants.map(({ name }, i) => ` case ${JSON.stringify(name)}:
|
||
writer.writeByte(${i});
|
||
return this.${name}(writer, value.value);`).join("\n")}
|
||
default:
|
||
throw new TypeError(
|
||
\`Could not serialize sum type; unknown tag \${value.tag}\`
|
||
)
|
||
}
|
||
`;
|
||
serializer = Function("writer", "value", body).bind(serializers);
|
||
SERIALIZERS.set(ty, serializer);
|
||
for (const { name, algebraicType } of ty.variants) serializers[name] = AlgebraicType.makeSerializer(algebraicType, typespace);
|
||
Object.freeze(serializers);
|
||
return serializer;
|
||
}
|
||
},
|
||
serializeValue(writer, ty, value, typespace) {
|
||
SumType.makeSerializer(ty, typespace)(writer, value);
|
||
},
|
||
makeDeserializer(ty, typespace) {
|
||
if (ty.variants.length == 2 && ty.variants[0].name === "some" && ty.variants[1].name === "none") {
|
||
const deserialize = AlgebraicType.makeDeserializer(ty.variants[0].algebraicType, typespace);
|
||
return (reader) => {
|
||
const tag = reader.readU8();
|
||
if (tag === 0) return deserialize(reader);
|
||
else if (tag === 1) return;
|
||
else throw `Can't deserialize an option type, couldn't find ${tag} tag`;
|
||
};
|
||
} else if (ty.variants.length == 2 && ty.variants[0].name === "ok" && ty.variants[1].name === "err") {
|
||
const deserializeOk = AlgebraicType.makeDeserializer(ty.variants[0].algebraicType, typespace);
|
||
const deserializeErr = AlgebraicType.makeDeserializer(ty.variants[1].algebraicType, typespace);
|
||
return (reader) => {
|
||
const tag = reader.readByte();
|
||
if (tag === 0) return { ok: deserializeOk(reader) };
|
||
else if (tag === 1) return { err: deserializeErr(reader) };
|
||
else throw `Can't deserialize a result type, couldn't find ${tag} tag`;
|
||
};
|
||
} else {
|
||
let deserializer = DESERIALIZERS.get(ty);
|
||
if (deserializer != null) return deserializer;
|
||
const deserializers = {};
|
||
deserializer = Function("reader", `switch (reader.readU8()) {
|
||
${ty.variants.map(({ name }, i) => `case ${i}: return { tag: ${JSON.stringify(name)}, value: this.${name}(reader) };`).join("\n")} }`).bind(deserializers);
|
||
DESERIALIZERS.set(ty, deserializer);
|
||
for (const { name, algebraicType } of ty.variants) deserializers[name] = AlgebraicType.makeDeserializer(algebraicType, typespace);
|
||
Object.freeze(deserializers);
|
||
return deserializer;
|
||
}
|
||
},
|
||
deserializeValue(reader, ty, typespace) {
|
||
return SumType.makeDeserializer(ty, typespace)(reader);
|
||
}
|
||
};
|
||
var Option = { getAlgebraicType(innerType) {
|
||
return AlgebraicType.Sum({ variants: [{
|
||
name: "some",
|
||
algebraicType: innerType
|
||
}, {
|
||
name: "none",
|
||
algebraicType: AlgebraicType.Product({ elements: [] })
|
||
}] });
|
||
} };
|
||
var Result = { getAlgebraicType(okType, errType) {
|
||
return AlgebraicType.Sum({ variants: [{
|
||
name: "ok",
|
||
algebraicType: okType
|
||
}, {
|
||
name: "err",
|
||
algebraicType: errType
|
||
}] });
|
||
} };
|
||
var ScheduleAt = {
|
||
interval(value) {
|
||
return Interval(value);
|
||
},
|
||
time(value) {
|
||
return Time(value);
|
||
},
|
||
getAlgebraicType() {
|
||
return AlgebraicType.Sum({ variants: [{
|
||
name: "Interval",
|
||
algebraicType: TimeDuration.getAlgebraicType()
|
||
}, {
|
||
name: "Time",
|
||
algebraicType: Timestamp.getAlgebraicType()
|
||
}] });
|
||
},
|
||
isScheduleAt(algebraicType) {
|
||
if (algebraicType.tag !== "Sum") return false;
|
||
const variants = algebraicType.value.variants;
|
||
if (variants.length !== 2) return false;
|
||
const intervalVariant = variants.find((v) => v.name === "Interval");
|
||
const timeVariant = variants.find((v) => v.name === "Time");
|
||
if (!intervalVariant || !timeVariant) return false;
|
||
return TimeDuration.isTimeDuration(intervalVariant.algebraicType) && Timestamp.isTimestamp(timeVariant.algebraicType);
|
||
}
|
||
};
|
||
var Interval = (micros) => ({
|
||
tag: "Interval",
|
||
value: new TimeDuration(micros)
|
||
});
|
||
var Time = (microsSinceUnixEpoch) => ({
|
||
tag: "Time",
|
||
value: new Timestamp(microsSinceUnixEpoch)
|
||
});
|
||
var schedule_at_default = ScheduleAt;
|
||
function set(x, t2) {
|
||
return {
|
||
...x,
|
||
...t2
|
||
};
|
||
}
|
||
var TypeBuilder = class {
|
||
/**
|
||
* The TypeScript phantom type. This is not stored at runtime,
|
||
* but is visible to the compiler
|
||
*/
|
||
type;
|
||
/**
|
||
* The SpacetimeDB algebraic type (run‑time value). In addition to storing
|
||
* the runtime representation of the `AlgebraicType`, it also captures
|
||
* the TypeScript type information of the `AlgebraicType`. That is to say
|
||
* the value is not merely an `AlgebraicType`, but is constructed to be
|
||
* the corresponding concrete `AlgebraicType` for the TypeScript type `Type`.
|
||
*
|
||
* e.g. `string` corresponds to `AlgebraicType.String`
|
||
*/
|
||
algebraicType;
|
||
constructor(algebraicType) {
|
||
this.algebraicType = algebraicType;
|
||
}
|
||
optional() {
|
||
return new OptionBuilder(this);
|
||
}
|
||
serialize(writer, value) {
|
||
(this.serialize = AlgebraicType.makeSerializer(this.algebraicType))(writer, value);
|
||
}
|
||
deserialize(reader) {
|
||
return (this.deserialize = AlgebraicType.makeDeserializer(this.algebraicType))(reader);
|
||
}
|
||
};
|
||
var U8Builder = class extends TypeBuilder {
|
||
constructor() {
|
||
super(AlgebraicType.U8);
|
||
}
|
||
index(algorithm = "btree") {
|
||
return new U8ColumnBuilder(this, set(defaultMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new U8ColumnBuilder(this, set(defaultMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new U8ColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true }));
|
||
}
|
||
autoInc() {
|
||
return new U8ColumnBuilder(this, set(defaultMetadata, { isAutoIncrement: true }));
|
||
}
|
||
default(value) {
|
||
return new U8ColumnBuilder(this, set(defaultMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new U8ColumnBuilder(this, set(defaultMetadata, { name }));
|
||
}
|
||
};
|
||
var U16Builder = class extends TypeBuilder {
|
||
constructor() {
|
||
super(AlgebraicType.U16);
|
||
}
|
||
index(algorithm = "btree") {
|
||
return new U16ColumnBuilder(this, set(defaultMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new U16ColumnBuilder(this, set(defaultMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new U16ColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true }));
|
||
}
|
||
autoInc() {
|
||
return new U16ColumnBuilder(this, set(defaultMetadata, { isAutoIncrement: true }));
|
||
}
|
||
default(value) {
|
||
return new U16ColumnBuilder(this, set(defaultMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new U16ColumnBuilder(this, set(defaultMetadata, { name }));
|
||
}
|
||
};
|
||
var U32Builder = class extends TypeBuilder {
|
||
constructor() {
|
||
super(AlgebraicType.U32);
|
||
}
|
||
index(algorithm = "btree") {
|
||
return new U32ColumnBuilder(this, set(defaultMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new U32ColumnBuilder(this, set(defaultMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new U32ColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true }));
|
||
}
|
||
autoInc() {
|
||
return new U32ColumnBuilder(this, set(defaultMetadata, { isAutoIncrement: true }));
|
||
}
|
||
default(value) {
|
||
return new U32ColumnBuilder(this, set(defaultMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new U32ColumnBuilder(this, set(defaultMetadata, { name }));
|
||
}
|
||
};
|
||
var U64Builder = class extends TypeBuilder {
|
||
constructor() {
|
||
super(AlgebraicType.U64);
|
||
}
|
||
index(algorithm = "btree") {
|
||
return new U64ColumnBuilder(this, set(defaultMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new U64ColumnBuilder(this, set(defaultMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new U64ColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true }));
|
||
}
|
||
autoInc() {
|
||
return new U64ColumnBuilder(this, set(defaultMetadata, { isAutoIncrement: true }));
|
||
}
|
||
default(value) {
|
||
return new U64ColumnBuilder(this, set(defaultMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new U64ColumnBuilder(this, set(defaultMetadata, { name }));
|
||
}
|
||
};
|
||
var U128Builder = class extends TypeBuilder {
|
||
constructor() {
|
||
super(AlgebraicType.U128);
|
||
}
|
||
index(algorithm = "btree") {
|
||
return new U128ColumnBuilder(this, set(defaultMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new U128ColumnBuilder(this, set(defaultMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new U128ColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true }));
|
||
}
|
||
autoInc() {
|
||
return new U128ColumnBuilder(this, set(defaultMetadata, { isAutoIncrement: true }));
|
||
}
|
||
default(value) {
|
||
return new U128ColumnBuilder(this, set(defaultMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new U128ColumnBuilder(this, set(defaultMetadata, { name }));
|
||
}
|
||
};
|
||
var U256Builder = class extends TypeBuilder {
|
||
constructor() {
|
||
super(AlgebraicType.U256);
|
||
}
|
||
index(algorithm = "btree") {
|
||
return new U256ColumnBuilder(this, set(defaultMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new U256ColumnBuilder(this, set(defaultMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new U256ColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true }));
|
||
}
|
||
autoInc() {
|
||
return new U256ColumnBuilder(this, set(defaultMetadata, { isAutoIncrement: true }));
|
||
}
|
||
default(value) {
|
||
return new U256ColumnBuilder(this, set(defaultMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new U256ColumnBuilder(this, set(defaultMetadata, { name }));
|
||
}
|
||
};
|
||
var I8Builder = class extends TypeBuilder {
|
||
constructor() {
|
||
super(AlgebraicType.I8);
|
||
}
|
||
index(algorithm = "btree") {
|
||
return new I8ColumnBuilder(this, set(defaultMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new I8ColumnBuilder(this, set(defaultMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new I8ColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true }));
|
||
}
|
||
autoInc() {
|
||
return new I8ColumnBuilder(this, set(defaultMetadata, { isAutoIncrement: true }));
|
||
}
|
||
default(value) {
|
||
return new I8ColumnBuilder(this, set(defaultMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new I8ColumnBuilder(this, set(defaultMetadata, { name }));
|
||
}
|
||
};
|
||
var I16Builder = class extends TypeBuilder {
|
||
constructor() {
|
||
super(AlgebraicType.I16);
|
||
}
|
||
index(algorithm = "btree") {
|
||
return new I16ColumnBuilder(this, set(defaultMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new I16ColumnBuilder(this, set(defaultMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new I16ColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true }));
|
||
}
|
||
autoInc() {
|
||
return new I16ColumnBuilder(this, set(defaultMetadata, { isAutoIncrement: true }));
|
||
}
|
||
default(value) {
|
||
return new I16ColumnBuilder(this, set(defaultMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new I16ColumnBuilder(this, set(defaultMetadata, { name }));
|
||
}
|
||
};
|
||
var I32Builder = class extends TypeBuilder {
|
||
constructor() {
|
||
super(AlgebraicType.I32);
|
||
}
|
||
index(algorithm = "btree") {
|
||
return new I32ColumnBuilder(this, set(defaultMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new I32ColumnBuilder(this, set(defaultMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new I32ColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true }));
|
||
}
|
||
autoInc() {
|
||
return new I32ColumnBuilder(this, set(defaultMetadata, { isAutoIncrement: true }));
|
||
}
|
||
default(value) {
|
||
return new I32ColumnBuilder(this, set(defaultMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new I32ColumnBuilder(this, set(defaultMetadata, { name }));
|
||
}
|
||
};
|
||
var I64Builder = class extends TypeBuilder {
|
||
constructor() {
|
||
super(AlgebraicType.I64);
|
||
}
|
||
index(algorithm = "btree") {
|
||
return new I64ColumnBuilder(this, set(defaultMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new I64ColumnBuilder(this, set(defaultMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new I64ColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true }));
|
||
}
|
||
autoInc() {
|
||
return new I64ColumnBuilder(this, set(defaultMetadata, { isAutoIncrement: true }));
|
||
}
|
||
default(value) {
|
||
return new I64ColumnBuilder(this, set(defaultMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new I64ColumnBuilder(this, set(defaultMetadata, { name }));
|
||
}
|
||
};
|
||
var I128Builder = class extends TypeBuilder {
|
||
constructor() {
|
||
super(AlgebraicType.I128);
|
||
}
|
||
index(algorithm = "btree") {
|
||
return new I128ColumnBuilder(this, set(defaultMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new I128ColumnBuilder(this, set(defaultMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new I128ColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true }));
|
||
}
|
||
autoInc() {
|
||
return new I128ColumnBuilder(this, set(defaultMetadata, { isAutoIncrement: true }));
|
||
}
|
||
default(value) {
|
||
return new I128ColumnBuilder(this, set(defaultMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new I128ColumnBuilder(this, set(defaultMetadata, { name }));
|
||
}
|
||
};
|
||
var I256Builder = class extends TypeBuilder {
|
||
constructor() {
|
||
super(AlgebraicType.I256);
|
||
}
|
||
index(algorithm = "btree") {
|
||
return new I256ColumnBuilder(this, set(defaultMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new I256ColumnBuilder(this, set(defaultMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new I256ColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true }));
|
||
}
|
||
autoInc() {
|
||
return new I256ColumnBuilder(this, set(defaultMetadata, { isAutoIncrement: true }));
|
||
}
|
||
default(value) {
|
||
return new I256ColumnBuilder(this, set(defaultMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new I256ColumnBuilder(this, set(defaultMetadata, { name }));
|
||
}
|
||
};
|
||
var F32Builder = class extends TypeBuilder {
|
||
constructor() {
|
||
super(AlgebraicType.F32);
|
||
}
|
||
default(value) {
|
||
return new F32ColumnBuilder(this, set(defaultMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new F32ColumnBuilder(this, set(defaultMetadata, { name }));
|
||
}
|
||
};
|
||
var F64Builder = class extends TypeBuilder {
|
||
constructor() {
|
||
super(AlgebraicType.F64);
|
||
}
|
||
default(value) {
|
||
return new F64ColumnBuilder(this, set(defaultMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new F64ColumnBuilder(this, set(defaultMetadata, { name }));
|
||
}
|
||
};
|
||
var BoolBuilder = class extends TypeBuilder {
|
||
constructor() {
|
||
super(AlgebraicType.Bool);
|
||
}
|
||
index(algorithm = "btree") {
|
||
return new BoolColumnBuilder(this, set(defaultMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new BoolColumnBuilder(this, set(defaultMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new BoolColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true }));
|
||
}
|
||
default(value) {
|
||
return new BoolColumnBuilder(this, set(defaultMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new BoolColumnBuilder(this, set(defaultMetadata, { name }));
|
||
}
|
||
};
|
||
var StringBuilder = class extends TypeBuilder {
|
||
constructor() {
|
||
super(AlgebraicType.String);
|
||
}
|
||
index(algorithm = "btree") {
|
||
return new StringColumnBuilder(this, set(defaultMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new StringColumnBuilder(this, set(defaultMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new StringColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true }));
|
||
}
|
||
default(value) {
|
||
return new StringColumnBuilder(this, set(defaultMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new StringColumnBuilder(this, set(defaultMetadata, { name }));
|
||
}
|
||
};
|
||
var ArrayBuilder = class extends TypeBuilder {
|
||
element;
|
||
constructor(element) {
|
||
super(AlgebraicType.Array(element.algebraicType));
|
||
this.element = element;
|
||
}
|
||
default(value) {
|
||
return new ArrayColumnBuilder(this, set(defaultMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new ArrayColumnBuilder(this, set(defaultMetadata, { name }));
|
||
}
|
||
};
|
||
var ByteArrayBuilder = class extends TypeBuilder {
|
||
constructor() {
|
||
super(AlgebraicType.Array(AlgebraicType.U8));
|
||
}
|
||
default(value) {
|
||
return new ByteArrayColumnBuilder(set(defaultMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new ByteArrayColumnBuilder(set(defaultMetadata, { name }));
|
||
}
|
||
};
|
||
var OptionBuilder = class extends TypeBuilder {
|
||
value;
|
||
constructor(value) {
|
||
super(Option.getAlgebraicType(value.algebraicType));
|
||
this.value = value;
|
||
}
|
||
default(value) {
|
||
return new OptionColumnBuilder(this, set(defaultMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new OptionColumnBuilder(this, set(defaultMetadata, { name }));
|
||
}
|
||
};
|
||
var ProductBuilder = class extends TypeBuilder {
|
||
typeName;
|
||
elements;
|
||
constructor(elements, name) {
|
||
function elementsArrayFromElementsObj(obj) {
|
||
return Object.keys(obj).map((key) => ({
|
||
name: key,
|
||
get algebraicType() {
|
||
return obj[key].algebraicType;
|
||
}
|
||
}));
|
||
}
|
||
super(AlgebraicType.Product({ elements: elementsArrayFromElementsObj(elements) }));
|
||
this.typeName = name;
|
||
this.elements = elements;
|
||
}
|
||
default(value) {
|
||
return new ProductColumnBuilder(this, set(defaultMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new ProductColumnBuilder(this, set(defaultMetadata, { name }));
|
||
}
|
||
};
|
||
var ResultBuilder = class extends TypeBuilder {
|
||
ok;
|
||
err;
|
||
constructor(ok, err) {
|
||
super(Result.getAlgebraicType(ok.algebraicType, err.algebraicType));
|
||
this.ok = ok;
|
||
this.err = err;
|
||
}
|
||
default(value) {
|
||
return new ResultColumnBuilder(this, set(defaultMetadata, { defaultValue: value }));
|
||
}
|
||
};
|
||
var UnitBuilder = class extends TypeBuilder {
|
||
constructor() {
|
||
super({
|
||
tag: "Product",
|
||
value: { elements: [] }
|
||
});
|
||
}
|
||
};
|
||
var RowBuilder = class extends TypeBuilder {
|
||
row;
|
||
typeName;
|
||
constructor(row, name) {
|
||
const mappedRow = Object.fromEntries(Object.entries(row).map(([colName, builder]) => [colName, builder instanceof ColumnBuilder ? builder : new ColumnBuilder(builder, {})]));
|
||
const elements = Object.keys(mappedRow).map((name2) => ({
|
||
name: name2,
|
||
get algebraicType() {
|
||
return mappedRow[name2].typeBuilder.algebraicType;
|
||
}
|
||
}));
|
||
super(AlgebraicType.Product({ elements }));
|
||
this.row = mappedRow;
|
||
this.typeName = name;
|
||
}
|
||
};
|
||
var SumBuilderImpl = class extends TypeBuilder {
|
||
variants;
|
||
typeName;
|
||
constructor(variants, name) {
|
||
function variantsArrayFromVariantsObj(variants2) {
|
||
return Object.keys(variants2).map((key) => ({
|
||
name: key,
|
||
get algebraicType() {
|
||
return variants2[key].algebraicType;
|
||
}
|
||
}));
|
||
}
|
||
super(AlgebraicType.Sum({ variants: variantsArrayFromVariantsObj(variants) }));
|
||
this.variants = variants;
|
||
this.typeName = name;
|
||
for (const key of Object.keys(variants)) {
|
||
const desc = Object.getOwnPropertyDescriptor(variants, key);
|
||
const isAccessor = !!desc && (typeof desc.get === "function" || typeof desc.set === "function");
|
||
let isUnit2 = false;
|
||
if (!isAccessor) isUnit2 = variants[key] instanceof UnitBuilder;
|
||
if (isUnit2) {
|
||
const constant = this.create(key);
|
||
Object.defineProperty(this, key, {
|
||
value: constant,
|
||
writable: false,
|
||
enumerable: true,
|
||
configurable: false
|
||
});
|
||
} else {
|
||
const fn = ((value) => this.create(key, value));
|
||
Object.defineProperty(this, key, {
|
||
value: fn,
|
||
writable: false,
|
||
enumerable: true,
|
||
configurable: false
|
||
});
|
||
}
|
||
}
|
||
}
|
||
create(tag, value) {
|
||
return value === void 0 ? { tag } : {
|
||
tag,
|
||
value
|
||
};
|
||
}
|
||
default(value) {
|
||
return new SumColumnBuilder(this, set(defaultMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new SumColumnBuilder(this, set(defaultMetadata, { name }));
|
||
}
|
||
};
|
||
var SumBuilder = SumBuilderImpl;
|
||
var SimpleSumBuilderImpl = class extends SumBuilderImpl {
|
||
index(algorithm = "btree") {
|
||
return new SimpleSumColumnBuilder(this, set(defaultMetadata, { indexType: algorithm }));
|
||
}
|
||
primaryKey() {
|
||
return new SimpleSumColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true }));
|
||
}
|
||
};
|
||
var ScheduleAtBuilder = class extends TypeBuilder {
|
||
constructor() {
|
||
super(schedule_at_default.getAlgebraicType());
|
||
}
|
||
default(value) {
|
||
return new ScheduleAtColumnBuilder(this, set(defaultMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new ScheduleAtColumnBuilder(this, set(defaultMetadata, { name }));
|
||
}
|
||
};
|
||
var IdentityBuilder = class extends TypeBuilder {
|
||
constructor() {
|
||
super(Identity.getAlgebraicType());
|
||
}
|
||
index(algorithm = "btree") {
|
||
return new IdentityColumnBuilder(this, set(defaultMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new IdentityColumnBuilder(this, set(defaultMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new IdentityColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true }));
|
||
}
|
||
autoInc() {
|
||
return new IdentityColumnBuilder(this, set(defaultMetadata, { isAutoIncrement: true }));
|
||
}
|
||
default(value) {
|
||
return new IdentityColumnBuilder(this, set(defaultMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new IdentityColumnBuilder(this, set(defaultMetadata, { name }));
|
||
}
|
||
};
|
||
var ConnectionIdBuilder = class extends TypeBuilder {
|
||
constructor() {
|
||
super(ConnectionId.getAlgebraicType());
|
||
}
|
||
index(algorithm = "btree") {
|
||
return new ConnectionIdColumnBuilder(this, set(defaultMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new ConnectionIdColumnBuilder(this, set(defaultMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new ConnectionIdColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true }));
|
||
}
|
||
autoInc() {
|
||
return new ConnectionIdColumnBuilder(this, set(defaultMetadata, { isAutoIncrement: true }));
|
||
}
|
||
default(value) {
|
||
return new ConnectionIdColumnBuilder(this, set(defaultMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new ConnectionIdColumnBuilder(this, set(defaultMetadata, { name }));
|
||
}
|
||
};
|
||
var TimestampBuilder = class extends TypeBuilder {
|
||
constructor() {
|
||
super(Timestamp.getAlgebraicType());
|
||
}
|
||
index(algorithm = "btree") {
|
||
return new TimestampColumnBuilder(this, set(defaultMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new TimestampColumnBuilder(this, set(defaultMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new TimestampColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true }));
|
||
}
|
||
autoInc() {
|
||
return new TimestampColumnBuilder(this, set(defaultMetadata, { isAutoIncrement: true }));
|
||
}
|
||
default(value) {
|
||
return new TimestampColumnBuilder(this, set(defaultMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new TimestampColumnBuilder(this, set(defaultMetadata, { name }));
|
||
}
|
||
};
|
||
var TimeDurationBuilder = class extends TypeBuilder {
|
||
constructor() {
|
||
super(TimeDuration.getAlgebraicType());
|
||
}
|
||
index(algorithm = "btree") {
|
||
return new TimeDurationColumnBuilder(this, set(defaultMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new TimeDurationColumnBuilder(this, set(defaultMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new TimeDurationColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true }));
|
||
}
|
||
autoInc() {
|
||
return new TimeDurationColumnBuilder(this, set(defaultMetadata, { isAutoIncrement: true }));
|
||
}
|
||
default(value) {
|
||
return new TimeDurationColumnBuilder(this, set(defaultMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new TimeDurationColumnBuilder(this, set(defaultMetadata, { name }));
|
||
}
|
||
};
|
||
var UuidBuilder = class extends TypeBuilder {
|
||
constructor() {
|
||
super(Uuid.getAlgebraicType());
|
||
}
|
||
index(algorithm = "btree") {
|
||
return new UuidColumnBuilder(this, set(defaultMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new UuidColumnBuilder(this, set(defaultMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new UuidColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true }));
|
||
}
|
||
autoInc() {
|
||
return new UuidColumnBuilder(this, set(defaultMetadata, { isAutoIncrement: true }));
|
||
}
|
||
default(value) {
|
||
return new UuidColumnBuilder(this, set(defaultMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new UuidColumnBuilder(this, set(defaultMetadata, { name }));
|
||
}
|
||
};
|
||
var defaultMetadata = {};
|
||
var ColumnBuilder = class {
|
||
typeBuilder;
|
||
columnMetadata;
|
||
constructor(typeBuilder, metadata) {
|
||
this.typeBuilder = typeBuilder;
|
||
this.columnMetadata = metadata;
|
||
}
|
||
serialize(writer, value) {
|
||
this.typeBuilder.serialize(writer, value);
|
||
}
|
||
deserialize(reader) {
|
||
return this.typeBuilder.deserialize(reader);
|
||
}
|
||
};
|
||
var U8ColumnBuilder = class _U8ColumnBuilder extends ColumnBuilder {
|
||
index(algorithm = "btree") {
|
||
return new _U8ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new _U8ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new _U8ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true }));
|
||
}
|
||
autoInc() {
|
||
return new _U8ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isAutoIncrement: true }));
|
||
}
|
||
default(value) {
|
||
return new _U8ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new _U8ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name }));
|
||
}
|
||
};
|
||
var U16ColumnBuilder = class _U16ColumnBuilder extends ColumnBuilder {
|
||
index(algorithm = "btree") {
|
||
return new _U16ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new _U16ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new _U16ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true }));
|
||
}
|
||
autoInc() {
|
||
return new _U16ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isAutoIncrement: true }));
|
||
}
|
||
default(value) {
|
||
return new _U16ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new _U16ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name }));
|
||
}
|
||
};
|
||
var U32ColumnBuilder = class _U32ColumnBuilder extends ColumnBuilder {
|
||
index(algorithm = "btree") {
|
||
return new _U32ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new _U32ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new _U32ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true }));
|
||
}
|
||
autoInc() {
|
||
return new _U32ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isAutoIncrement: true }));
|
||
}
|
||
default(value) {
|
||
return new _U32ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new _U32ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name }));
|
||
}
|
||
};
|
||
var U64ColumnBuilder = class _U64ColumnBuilder extends ColumnBuilder {
|
||
index(algorithm = "btree") {
|
||
return new _U64ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new _U64ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new _U64ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true }));
|
||
}
|
||
autoInc() {
|
||
return new _U64ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isAutoIncrement: true }));
|
||
}
|
||
default(value) {
|
||
return new _U64ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new _U64ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name }));
|
||
}
|
||
};
|
||
var U128ColumnBuilder = class _U128ColumnBuilder extends ColumnBuilder {
|
||
index(algorithm = "btree") {
|
||
return new _U128ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new _U128ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new _U128ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true }));
|
||
}
|
||
autoInc() {
|
||
return new _U128ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isAutoIncrement: true }));
|
||
}
|
||
default(value) {
|
||
return new _U128ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new _U128ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name }));
|
||
}
|
||
};
|
||
var U256ColumnBuilder = class _U256ColumnBuilder extends ColumnBuilder {
|
||
index(algorithm = "btree") {
|
||
return new _U256ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new _U256ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new _U256ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true }));
|
||
}
|
||
autoInc() {
|
||
return new _U256ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isAutoIncrement: true }));
|
||
}
|
||
default(value) {
|
||
return new _U256ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new _U256ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name }));
|
||
}
|
||
};
|
||
var I8ColumnBuilder = class _I8ColumnBuilder extends ColumnBuilder {
|
||
index(algorithm = "btree") {
|
||
return new _I8ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new _I8ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new _I8ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true }));
|
||
}
|
||
autoInc() {
|
||
return new _I8ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isAutoIncrement: true }));
|
||
}
|
||
default(value) {
|
||
return new _I8ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new _I8ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name }));
|
||
}
|
||
};
|
||
var I16ColumnBuilder = class _I16ColumnBuilder extends ColumnBuilder {
|
||
index(algorithm = "btree") {
|
||
return new _I16ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new _I16ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new _I16ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true }));
|
||
}
|
||
autoInc() {
|
||
return new _I16ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isAutoIncrement: true }));
|
||
}
|
||
default(value) {
|
||
return new _I16ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new _I16ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name }));
|
||
}
|
||
};
|
||
var I32ColumnBuilder = class _I32ColumnBuilder extends ColumnBuilder {
|
||
index(algorithm = "btree") {
|
||
return new _I32ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new _I32ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new _I32ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true }));
|
||
}
|
||
autoInc() {
|
||
return new _I32ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isAutoIncrement: true }));
|
||
}
|
||
default(value) {
|
||
return new _I32ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new _I32ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name }));
|
||
}
|
||
};
|
||
var I64ColumnBuilder = class _I64ColumnBuilder extends ColumnBuilder {
|
||
index(algorithm = "btree") {
|
||
return new _I64ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new _I64ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new _I64ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true }));
|
||
}
|
||
autoInc() {
|
||
return new _I64ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isAutoIncrement: true }));
|
||
}
|
||
default(value) {
|
||
return new _I64ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new _I64ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name }));
|
||
}
|
||
};
|
||
var I128ColumnBuilder = class _I128ColumnBuilder extends ColumnBuilder {
|
||
index(algorithm = "btree") {
|
||
return new _I128ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new _I128ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new _I128ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true }));
|
||
}
|
||
autoInc() {
|
||
return new _I128ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isAutoIncrement: true }));
|
||
}
|
||
default(value) {
|
||
return new _I128ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new _I128ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name }));
|
||
}
|
||
};
|
||
var I256ColumnBuilder = class _I256ColumnBuilder extends ColumnBuilder {
|
||
index(algorithm = "btree") {
|
||
return new _I256ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new _I256ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new _I256ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true }));
|
||
}
|
||
autoInc() {
|
||
return new _I256ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isAutoIncrement: true }));
|
||
}
|
||
default(value) {
|
||
return new _I256ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new _I256ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name }));
|
||
}
|
||
};
|
||
var F32ColumnBuilder = class _F32ColumnBuilder extends ColumnBuilder {
|
||
default(value) {
|
||
return new _F32ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new _F32ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name }));
|
||
}
|
||
};
|
||
var F64ColumnBuilder = class _F64ColumnBuilder extends ColumnBuilder {
|
||
default(value) {
|
||
return new _F64ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new _F64ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name }));
|
||
}
|
||
};
|
||
var BoolColumnBuilder = class _BoolColumnBuilder extends ColumnBuilder {
|
||
index(algorithm = "btree") {
|
||
return new _BoolColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new _BoolColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new _BoolColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true }));
|
||
}
|
||
default(value) {
|
||
return new _BoolColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new _BoolColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name }));
|
||
}
|
||
};
|
||
var StringColumnBuilder = class _StringColumnBuilder extends ColumnBuilder {
|
||
index(algorithm = "btree") {
|
||
return new _StringColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new _StringColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new _StringColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true }));
|
||
}
|
||
default(value) {
|
||
return new _StringColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new _StringColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name }));
|
||
}
|
||
};
|
||
var ArrayColumnBuilder = class _ArrayColumnBuilder extends ColumnBuilder {
|
||
default(value) {
|
||
return new _ArrayColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new _ArrayColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name }));
|
||
}
|
||
};
|
||
var ByteArrayColumnBuilder = class _ByteArrayColumnBuilder extends ColumnBuilder {
|
||
constructor(metadata) {
|
||
super(new TypeBuilder(AlgebraicType.Array(AlgebraicType.U8)), metadata);
|
||
}
|
||
default(value) {
|
||
return new _ByteArrayColumnBuilder(set(this.columnMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new _ByteArrayColumnBuilder(set(this.columnMetadata, { name }));
|
||
}
|
||
};
|
||
var OptionColumnBuilder = class _OptionColumnBuilder extends ColumnBuilder {
|
||
default(value) {
|
||
return new _OptionColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new _OptionColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name }));
|
||
}
|
||
};
|
||
var ResultColumnBuilder = class _ResultColumnBuilder extends ColumnBuilder {
|
||
constructor(typeBuilder, metadata) {
|
||
super(typeBuilder, metadata);
|
||
}
|
||
default(value) {
|
||
return new _ResultColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value }));
|
||
}
|
||
};
|
||
var ProductColumnBuilder = class _ProductColumnBuilder extends ColumnBuilder {
|
||
default(value) {
|
||
return new _ProductColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new _ProductColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name }));
|
||
}
|
||
};
|
||
var SumColumnBuilder = class _SumColumnBuilder extends ColumnBuilder {
|
||
default(value) {
|
||
return new _SumColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new _SumColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name }));
|
||
}
|
||
};
|
||
var SimpleSumColumnBuilder = class _SimpleSumColumnBuilder extends SumColumnBuilder {
|
||
index(algorithm = "btree") {
|
||
return new _SimpleSumColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm }));
|
||
}
|
||
primaryKey() {
|
||
return new _SimpleSumColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true }));
|
||
}
|
||
};
|
||
var ScheduleAtColumnBuilder = class _ScheduleAtColumnBuilder extends ColumnBuilder {
|
||
default(value) {
|
||
return new _ScheduleAtColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new _ScheduleAtColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name }));
|
||
}
|
||
};
|
||
var IdentityColumnBuilder = class _IdentityColumnBuilder extends ColumnBuilder {
|
||
index(algorithm = "btree") {
|
||
return new _IdentityColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new _IdentityColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new _IdentityColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true }));
|
||
}
|
||
default(value) {
|
||
return new _IdentityColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new _IdentityColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name }));
|
||
}
|
||
};
|
||
var ConnectionIdColumnBuilder = class _ConnectionIdColumnBuilder extends ColumnBuilder {
|
||
index(algorithm = "btree") {
|
||
return new _ConnectionIdColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new _ConnectionIdColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new _ConnectionIdColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true }));
|
||
}
|
||
default(value) {
|
||
return new _ConnectionIdColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new _ConnectionIdColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name }));
|
||
}
|
||
};
|
||
var TimestampColumnBuilder = class _TimestampColumnBuilder extends ColumnBuilder {
|
||
index(algorithm = "btree") {
|
||
return new _TimestampColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new _TimestampColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new _TimestampColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true }));
|
||
}
|
||
default(value) {
|
||
return new _TimestampColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new _TimestampColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name }));
|
||
}
|
||
};
|
||
var TimeDurationColumnBuilder = class _TimeDurationColumnBuilder extends ColumnBuilder {
|
||
index(algorithm = "btree") {
|
||
return new _TimeDurationColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new _TimeDurationColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new _TimeDurationColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true }));
|
||
}
|
||
default(value) {
|
||
return new _TimeDurationColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new _TimeDurationColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name }));
|
||
}
|
||
};
|
||
var UuidColumnBuilder = class _UuidColumnBuilder extends ColumnBuilder {
|
||
index(algorithm = "btree") {
|
||
return new _UuidColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm }));
|
||
}
|
||
unique() {
|
||
return new _UuidColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true }));
|
||
}
|
||
primaryKey() {
|
||
return new _UuidColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true }));
|
||
}
|
||
default(value) {
|
||
return new _UuidColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value }));
|
||
}
|
||
name(name) {
|
||
return new _UuidColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name }));
|
||
}
|
||
};
|
||
var RefBuilder = class extends TypeBuilder {
|
||
ref;
|
||
/** The phantom type of the pointee of this ref. */
|
||
__spacetimeType;
|
||
constructor(ref) {
|
||
super(AlgebraicType.Ref(ref));
|
||
this.ref = ref;
|
||
}
|
||
};
|
||
var enumImpl = ((nameOrObj, maybeObj) => {
|
||
let obj = nameOrObj;
|
||
let name = void 0;
|
||
if (typeof nameOrObj === "string") {
|
||
if (!maybeObj) throw new TypeError("When providing a name, you must also provide the variants object or array.");
|
||
obj = maybeObj;
|
||
name = nameOrObj;
|
||
}
|
||
if (Array.isArray(obj)) {
|
||
const simpleVariantsObj = {};
|
||
for (const variant of obj) simpleVariantsObj[variant] = new UnitBuilder();
|
||
return new SimpleSumBuilderImpl(simpleVariantsObj, name);
|
||
}
|
||
return new SumBuilder(obj, name);
|
||
});
|
||
var t = {
|
||
bool: () => new BoolBuilder(),
|
||
string: () => new StringBuilder(),
|
||
number: () => new F64Builder(),
|
||
i8: () => new I8Builder(),
|
||
u8: () => new U8Builder(),
|
||
i16: () => new I16Builder(),
|
||
u16: () => new U16Builder(),
|
||
i32: () => new I32Builder(),
|
||
u32: () => new U32Builder(),
|
||
i64: () => new I64Builder(),
|
||
u64: () => new U64Builder(),
|
||
i128: () => new I128Builder(),
|
||
u128: () => new U128Builder(),
|
||
i256: () => new I256Builder(),
|
||
u256: () => new U256Builder(),
|
||
f32: () => new F32Builder(),
|
||
f64: () => new F64Builder(),
|
||
object: ((nameOrObj, maybeObj) => {
|
||
if (typeof nameOrObj === "string") {
|
||
if (!maybeObj) throw new TypeError("When providing a name, you must also provide the object.");
|
||
return new ProductBuilder(maybeObj, nameOrObj);
|
||
}
|
||
return new ProductBuilder(nameOrObj, void 0);
|
||
}),
|
||
row: ((nameOrObj, maybeObj) => {
|
||
const [obj, name] = typeof nameOrObj === "string" ? [maybeObj, nameOrObj] : [nameOrObj, void 0];
|
||
return new RowBuilder(obj, name);
|
||
}),
|
||
array(e) {
|
||
return new ArrayBuilder(e);
|
||
},
|
||
enum: enumImpl,
|
||
unit() {
|
||
return new UnitBuilder();
|
||
},
|
||
lazy(thunk) {
|
||
let cached = null;
|
||
const get = () => cached ??= thunk();
|
||
return new Proxy({}, {
|
||
get(_t, prop, recv) {
|
||
const target = get();
|
||
const val = Reflect.get(target, prop, recv);
|
||
return typeof val === "function" ? val.bind(target) : val;
|
||
},
|
||
set(_t, prop, value, recv) {
|
||
return Reflect.set(get(), prop, value, recv);
|
||
},
|
||
has(_t, prop) {
|
||
return prop in get();
|
||
},
|
||
ownKeys() {
|
||
return Reflect.ownKeys(get());
|
||
},
|
||
getOwnPropertyDescriptor(_t, prop) {
|
||
return Object.getOwnPropertyDescriptor(get(), prop);
|
||
},
|
||
getPrototypeOf() {
|
||
return Object.getPrototypeOf(get());
|
||
}
|
||
});
|
||
},
|
||
scheduleAt: () => {
|
||
return new ScheduleAtBuilder();
|
||
},
|
||
option(value) {
|
||
return new OptionBuilder(value);
|
||
},
|
||
result(ok, err) {
|
||
return new ResultBuilder(ok, err);
|
||
},
|
||
identity: () => {
|
||
return new IdentityBuilder();
|
||
},
|
||
connectionId: () => {
|
||
return new ConnectionIdBuilder();
|
||
},
|
||
timestamp: () => {
|
||
return new TimestampBuilder();
|
||
},
|
||
timeDuration: () => {
|
||
return new TimeDurationBuilder();
|
||
},
|
||
uuid: () => {
|
||
return new UuidBuilder();
|
||
},
|
||
byteArray: () => {
|
||
return new ByteArrayBuilder();
|
||
}
|
||
};
|
||
var AlgebraicType2 = t.enum("AlgebraicType", {
|
||
Ref: t.u32(),
|
||
get Sum() {
|
||
return SumType2;
|
||
},
|
||
get Product() {
|
||
return ProductType2;
|
||
},
|
||
get Array() {
|
||
return AlgebraicType2;
|
||
},
|
||
String: t.unit(),
|
||
Bool: t.unit(),
|
||
I8: t.unit(),
|
||
U8: t.unit(),
|
||
I16: t.unit(),
|
||
U16: t.unit(),
|
||
I32: t.unit(),
|
||
U32: t.unit(),
|
||
I64: t.unit(),
|
||
U64: t.unit(),
|
||
I128: t.unit(),
|
||
U128: t.unit(),
|
||
I256: t.unit(),
|
||
U256: t.unit(),
|
||
F32: t.unit(),
|
||
F64: t.unit()
|
||
});
|
||
var CaseConversionPolicy = t.enum("CaseConversionPolicy", {
|
||
None: t.unit(),
|
||
SnakeCase: t.unit()
|
||
});
|
||
var ExplicitNameEntry = t.enum("ExplicitNameEntry", {
|
||
get Table() {
|
||
return NameMapping;
|
||
},
|
||
get Function() {
|
||
return NameMapping;
|
||
},
|
||
get Index() {
|
||
return NameMapping;
|
||
}
|
||
});
|
||
var ExplicitNames = t.object("ExplicitNames", { get entries() {
|
||
return t.array(ExplicitNameEntry);
|
||
} });
|
||
var FunctionVisibility = t.enum("FunctionVisibility", {
|
||
Private: t.unit(),
|
||
ClientCallable: t.unit()
|
||
});
|
||
var HttpHeaderPair = t.object("HttpHeaderPair", {
|
||
name: t.string(),
|
||
value: t.byteArray()
|
||
});
|
||
var HttpHeaders = t.object("HttpHeaders", { get entries() {
|
||
return t.array(HttpHeaderPair);
|
||
} });
|
||
var HttpMethod = t.enum("HttpMethod", {
|
||
Get: t.unit(),
|
||
Head: t.unit(),
|
||
Post: t.unit(),
|
||
Put: t.unit(),
|
||
Delete: t.unit(),
|
||
Connect: t.unit(),
|
||
Options: t.unit(),
|
||
Trace: t.unit(),
|
||
Patch: t.unit(),
|
||
Extension: t.string()
|
||
});
|
||
var HttpRequest = t.object("HttpRequest", {
|
||
get method() {
|
||
return HttpMethod;
|
||
},
|
||
get headers() {
|
||
return HttpHeaders;
|
||
},
|
||
timeout: t.option(t.timeDuration()),
|
||
uri: t.string(),
|
||
get version() {
|
||
return HttpVersion;
|
||
}
|
||
});
|
||
var HttpResponse = t.object("HttpResponse", {
|
||
get headers() {
|
||
return HttpHeaders;
|
||
},
|
||
get version() {
|
||
return HttpVersion;
|
||
},
|
||
code: t.u16()
|
||
});
|
||
var HttpVersion = t.enum("HttpVersion", {
|
||
Http09: t.unit(),
|
||
Http10: t.unit(),
|
||
Http11: t.unit(),
|
||
Http2: t.unit(),
|
||
Http3: t.unit()
|
||
});
|
||
var IndexType = t.enum("IndexType", {
|
||
BTree: t.unit(),
|
||
Hash: t.unit()
|
||
});
|
||
var Lifecycle = t.enum("Lifecycle", {
|
||
Init: t.unit(),
|
||
OnConnect: t.unit(),
|
||
OnDisconnect: t.unit()
|
||
});
|
||
var MiscModuleExport = t.enum("MiscModuleExport", { get TypeAlias() {
|
||
return TypeAlias;
|
||
} });
|
||
var NameMapping = t.object("NameMapping", {
|
||
sourceName: t.string(),
|
||
canonicalName: t.string()
|
||
});
|
||
var ProductType2 = t.object("ProductType", { get elements() {
|
||
return t.array(ProductTypeElement);
|
||
} });
|
||
var ProductTypeElement = t.object("ProductTypeElement", {
|
||
name: t.option(t.string()),
|
||
get algebraicType() {
|
||
return AlgebraicType2;
|
||
}
|
||
});
|
||
var RawColumnDefV8 = t.object("RawColumnDefV8", {
|
||
colName: t.string(),
|
||
get colType() {
|
||
return AlgebraicType2;
|
||
}
|
||
});
|
||
var RawColumnDefaultValueV10 = t.object("RawColumnDefaultValueV10", {
|
||
colId: t.u16(),
|
||
value: t.byteArray()
|
||
});
|
||
var RawColumnDefaultValueV9 = t.object("RawColumnDefaultValueV9", {
|
||
table: t.string(),
|
||
colId: t.u16(),
|
||
value: t.byteArray()
|
||
});
|
||
var RawConstraintDataV9 = t.enum("RawConstraintDataV9", { get Unique() {
|
||
return RawUniqueConstraintDataV9;
|
||
} });
|
||
var RawConstraintDefV10 = t.object("RawConstraintDefV10", {
|
||
sourceName: t.option(t.string()),
|
||
get data() {
|
||
return RawConstraintDataV9;
|
||
}
|
||
});
|
||
var RawConstraintDefV8 = t.object("RawConstraintDefV8", {
|
||
constraintName: t.string(),
|
||
constraints: t.u8(),
|
||
columns: t.array(t.u16())
|
||
});
|
||
var RawConstraintDefV9 = t.object("RawConstraintDefV9", {
|
||
name: t.option(t.string()),
|
||
get data() {
|
||
return RawConstraintDataV9;
|
||
}
|
||
});
|
||
var RawIndexAlgorithm = t.enum("RawIndexAlgorithm", {
|
||
BTree: t.array(t.u16()),
|
||
Hash: t.array(t.u16()),
|
||
Direct: t.u16()
|
||
});
|
||
var RawIndexDefV10 = t.object("RawIndexDefV10", {
|
||
sourceName: t.option(t.string()),
|
||
accessorName: t.option(t.string()),
|
||
get algorithm() {
|
||
return RawIndexAlgorithm;
|
||
}
|
||
});
|
||
var RawIndexDefV8 = t.object("RawIndexDefV8", {
|
||
indexName: t.string(),
|
||
isUnique: t.bool(),
|
||
get indexType() {
|
||
return IndexType;
|
||
},
|
||
columns: t.array(t.u16())
|
||
});
|
||
var RawIndexDefV9 = t.object("RawIndexDefV9", {
|
||
name: t.option(t.string()),
|
||
accessorName: t.option(t.string()),
|
||
get algorithm() {
|
||
return RawIndexAlgorithm;
|
||
}
|
||
});
|
||
var RawLifeCycleReducerDefV10 = t.object("RawLifeCycleReducerDefV10", {
|
||
get lifecycleSpec() {
|
||
return Lifecycle;
|
||
},
|
||
functionName: t.string()
|
||
});
|
||
var RawMiscModuleExportV9 = t.enum("RawMiscModuleExportV9", {
|
||
get ColumnDefaultValue() {
|
||
return RawColumnDefaultValueV9;
|
||
},
|
||
get Procedure() {
|
||
return RawProcedureDefV9;
|
||
},
|
||
get View() {
|
||
return RawViewDefV9;
|
||
}
|
||
});
|
||
var RawModuleDef = t.enum("RawModuleDef", {
|
||
get V8BackCompat() {
|
||
return RawModuleDefV8;
|
||
},
|
||
get V9() {
|
||
return RawModuleDefV9;
|
||
},
|
||
get V10() {
|
||
return RawModuleDefV10;
|
||
}
|
||
});
|
||
var RawModuleDefV10 = t.object("RawModuleDefV10", { get sections() {
|
||
return t.array(RawModuleDefV10Section);
|
||
} });
|
||
var RawModuleDefV10Section = t.enum("RawModuleDefV10Section", {
|
||
get Typespace() {
|
||
return Typespace;
|
||
},
|
||
get Types() {
|
||
return t.array(RawTypeDefV10);
|
||
},
|
||
get Tables() {
|
||
return t.array(RawTableDefV10);
|
||
},
|
||
get Reducers() {
|
||
return t.array(RawReducerDefV10);
|
||
},
|
||
get Procedures() {
|
||
return t.array(RawProcedureDefV10);
|
||
},
|
||
get Views() {
|
||
return t.array(RawViewDefV10);
|
||
},
|
||
get Schedules() {
|
||
return t.array(RawScheduleDefV10);
|
||
},
|
||
get LifeCycleReducers() {
|
||
return t.array(RawLifeCycleReducerDefV10);
|
||
},
|
||
get RowLevelSecurity() {
|
||
return t.array(RawRowLevelSecurityDefV9);
|
||
},
|
||
get CaseConversionPolicy() {
|
||
return CaseConversionPolicy;
|
||
},
|
||
get ExplicitNames() {
|
||
return ExplicitNames;
|
||
}
|
||
});
|
||
var RawModuleDefV8 = t.object("RawModuleDefV8", {
|
||
get typespace() {
|
||
return Typespace;
|
||
},
|
||
get tables() {
|
||
return t.array(TableDesc);
|
||
},
|
||
get reducers() {
|
||
return t.array(ReducerDef);
|
||
},
|
||
get miscExports() {
|
||
return t.array(MiscModuleExport);
|
||
}
|
||
});
|
||
var RawModuleDefV9 = t.object("RawModuleDefV9", {
|
||
get typespace() {
|
||
return Typespace;
|
||
},
|
||
get tables() {
|
||
return t.array(RawTableDefV9);
|
||
},
|
||
get reducers() {
|
||
return t.array(RawReducerDefV9);
|
||
},
|
||
get types() {
|
||
return t.array(RawTypeDefV9);
|
||
},
|
||
get miscExports() {
|
||
return t.array(RawMiscModuleExportV9);
|
||
},
|
||
get rowLevelSecurity() {
|
||
return t.array(RawRowLevelSecurityDefV9);
|
||
}
|
||
});
|
||
var RawProcedureDefV10 = t.object("RawProcedureDefV10", {
|
||
sourceName: t.string(),
|
||
get params() {
|
||
return ProductType2;
|
||
},
|
||
get returnType() {
|
||
return AlgebraicType2;
|
||
},
|
||
get visibility() {
|
||
return FunctionVisibility;
|
||
}
|
||
});
|
||
var RawProcedureDefV9 = t.object("RawProcedureDefV9", {
|
||
name: t.string(),
|
||
get params() {
|
||
return ProductType2;
|
||
},
|
||
get returnType() {
|
||
return AlgebraicType2;
|
||
}
|
||
});
|
||
var RawReducerDefV10 = t.object("RawReducerDefV10", {
|
||
sourceName: t.string(),
|
||
get params() {
|
||
return ProductType2;
|
||
},
|
||
get visibility() {
|
||
return FunctionVisibility;
|
||
},
|
||
get okReturnType() {
|
||
return AlgebraicType2;
|
||
},
|
||
get errReturnType() {
|
||
return AlgebraicType2;
|
||
}
|
||
});
|
||
var RawReducerDefV9 = t.object("RawReducerDefV9", {
|
||
name: t.string(),
|
||
get params() {
|
||
return ProductType2;
|
||
},
|
||
get lifecycle() {
|
||
return t.option(Lifecycle);
|
||
}
|
||
});
|
||
var RawRowLevelSecurityDefV9 = t.object("RawRowLevelSecurityDefV9", { sql: t.string() });
|
||
var RawScheduleDefV10 = t.object("RawScheduleDefV10", {
|
||
sourceName: t.option(t.string()),
|
||
tableName: t.string(),
|
||
scheduleAtCol: t.u16(),
|
||
functionName: t.string()
|
||
});
|
||
var RawScheduleDefV9 = t.object("RawScheduleDefV9", {
|
||
name: t.option(t.string()),
|
||
reducerName: t.string(),
|
||
scheduledAtColumn: t.u16()
|
||
});
|
||
var RawScopedTypeNameV10 = t.object("RawScopedTypeNameV10", {
|
||
scope: t.array(t.string()),
|
||
sourceName: t.string()
|
||
});
|
||
var RawScopedTypeNameV9 = t.object("RawScopedTypeNameV9", {
|
||
scope: t.array(t.string()),
|
||
name: t.string()
|
||
});
|
||
var RawSequenceDefV10 = t.object("RawSequenceDefV10", {
|
||
sourceName: t.option(t.string()),
|
||
column: t.u16(),
|
||
start: t.option(t.i128()),
|
||
minValue: t.option(t.i128()),
|
||
maxValue: t.option(t.i128()),
|
||
increment: t.i128()
|
||
});
|
||
var RawSequenceDefV8 = t.object("RawSequenceDefV8", {
|
||
sequenceName: t.string(),
|
||
colPos: t.u16(),
|
||
increment: t.i128(),
|
||
start: t.option(t.i128()),
|
||
minValue: t.option(t.i128()),
|
||
maxValue: t.option(t.i128()),
|
||
allocated: t.i128()
|
||
});
|
||
var RawSequenceDefV9 = t.object("RawSequenceDefV9", {
|
||
name: t.option(t.string()),
|
||
column: t.u16(),
|
||
start: t.option(t.i128()),
|
||
minValue: t.option(t.i128()),
|
||
maxValue: t.option(t.i128()),
|
||
increment: t.i128()
|
||
});
|
||
var RawTableDefV10 = t.object("RawTableDefV10", {
|
||
sourceName: t.string(),
|
||
productTypeRef: t.u32(),
|
||
primaryKey: t.array(t.u16()),
|
||
get indexes() {
|
||
return t.array(RawIndexDefV10);
|
||
},
|
||
get constraints() {
|
||
return t.array(RawConstraintDefV10);
|
||
},
|
||
get sequences() {
|
||
return t.array(RawSequenceDefV10);
|
||
},
|
||
get tableType() {
|
||
return TableType;
|
||
},
|
||
get tableAccess() {
|
||
return TableAccess;
|
||
},
|
||
get defaultValues() {
|
||
return t.array(RawColumnDefaultValueV10);
|
||
},
|
||
isEvent: t.bool()
|
||
});
|
||
var RawTableDefV8 = t.object("RawTableDefV8", {
|
||
tableName: t.string(),
|
||
get columns() {
|
||
return t.array(RawColumnDefV8);
|
||
},
|
||
get indexes() {
|
||
return t.array(RawIndexDefV8);
|
||
},
|
||
get constraints() {
|
||
return t.array(RawConstraintDefV8);
|
||
},
|
||
get sequences() {
|
||
return t.array(RawSequenceDefV8);
|
||
},
|
||
tableType: t.string(),
|
||
tableAccess: t.string(),
|
||
scheduled: t.option(t.string())
|
||
});
|
||
var RawTableDefV9 = t.object("RawTableDefV9", {
|
||
name: t.string(),
|
||
productTypeRef: t.u32(),
|
||
primaryKey: t.array(t.u16()),
|
||
get indexes() {
|
||
return t.array(RawIndexDefV9);
|
||
},
|
||
get constraints() {
|
||
return t.array(RawConstraintDefV9);
|
||
},
|
||
get sequences() {
|
||
return t.array(RawSequenceDefV9);
|
||
},
|
||
get schedule() {
|
||
return t.option(RawScheduleDefV9);
|
||
},
|
||
get tableType() {
|
||
return TableType;
|
||
},
|
||
get tableAccess() {
|
||
return TableAccess;
|
||
}
|
||
});
|
||
var RawTypeDefV10 = t.object("RawTypeDefV10", {
|
||
get sourceName() {
|
||
return RawScopedTypeNameV10;
|
||
},
|
||
ty: t.u32(),
|
||
customOrdering: t.bool()
|
||
});
|
||
var RawTypeDefV9 = t.object("RawTypeDefV9", {
|
||
get name() {
|
||
return RawScopedTypeNameV9;
|
||
},
|
||
ty: t.u32(),
|
||
customOrdering: t.bool()
|
||
});
|
||
var RawUniqueConstraintDataV9 = t.object("RawUniqueConstraintDataV9", { columns: t.array(t.u16()) });
|
||
var RawViewDefV10 = t.object("RawViewDefV10", {
|
||
sourceName: t.string(),
|
||
index: t.u32(),
|
||
isPublic: t.bool(),
|
||
isAnonymous: t.bool(),
|
||
get params() {
|
||
return ProductType2;
|
||
},
|
||
get returnType() {
|
||
return AlgebraicType2;
|
||
}
|
||
});
|
||
var RawViewDefV9 = t.object("RawViewDefV9", {
|
||
name: t.string(),
|
||
index: t.u32(),
|
||
isPublic: t.bool(),
|
||
isAnonymous: t.bool(),
|
||
get params() {
|
||
return ProductType2;
|
||
},
|
||
get returnType() {
|
||
return AlgebraicType2;
|
||
}
|
||
});
|
||
var ReducerDef = t.object("ReducerDef", {
|
||
name: t.string(),
|
||
get args() {
|
||
return t.array(ProductTypeElement);
|
||
}
|
||
});
|
||
var SumType2 = t.object("SumType", { get variants() {
|
||
return t.array(SumTypeVariant);
|
||
} });
|
||
var SumTypeVariant = t.object("SumTypeVariant", {
|
||
name: t.option(t.string()),
|
||
get algebraicType() {
|
||
return AlgebraicType2;
|
||
}
|
||
});
|
||
var TableAccess = t.enum("TableAccess", {
|
||
Public: t.unit(),
|
||
Private: t.unit()
|
||
});
|
||
var TableDesc = t.object("TableDesc", {
|
||
get schema() {
|
||
return RawTableDefV8;
|
||
},
|
||
data: t.u32()
|
||
});
|
||
var TableType = t.enum("TableType", {
|
||
System: t.unit(),
|
||
User: t.unit()
|
||
});
|
||
var TypeAlias = t.object("TypeAlias", {
|
||
name: t.string(),
|
||
ty: t.u32()
|
||
});
|
||
var Typespace = t.object("Typespace", { get types() {
|
||
return t.array(AlgebraicType2);
|
||
} });
|
||
var ViewResultHeader = t.enum("ViewResultHeader", {
|
||
RowData: t.unit(),
|
||
RawSql: t.string()
|
||
});
|
||
function tableToSchema(accName, schema2, tableDef) {
|
||
const getColName = (i) => schema2.rowType.algebraicType.value.elements[i].name;
|
||
const resolvedIndexes = tableDef.indexes.map((idx) => {
|
||
const accessorName = idx.accessorName;
|
||
if (typeof accessorName !== "string" || accessorName.length === 0) throw new TypeError(`Index '${idx.sourceName ?? "<unknown>"}' on table '${tableDef.sourceName}' is missing accessor name`);
|
||
const columnIds = idx.algorithm.tag === "Direct" ? [idx.algorithm.value] : idx.algorithm.value;
|
||
return {
|
||
name: accessorName,
|
||
unique: tableDef.constraints.some((c) => c.data.tag === "Unique" && c.data.value.columns.every((col) => columnIds.includes(col))),
|
||
algorithm: {
|
||
BTree: "btree",
|
||
Hash: "hash",
|
||
Direct: "direct"
|
||
}[idx.algorithm.tag],
|
||
columns: columnIds.map(getColName)
|
||
};
|
||
});
|
||
return {
|
||
sourceName: schema2.tableName || accName,
|
||
accessorName: accName,
|
||
columns: schema2.rowType.row,
|
||
rowType: schema2.rowSpacetimeType,
|
||
indexes: schema2.idxs,
|
||
constraints: tableDef.constraints.map((c) => ({
|
||
name: c.sourceName,
|
||
constraint: "unique",
|
||
columns: c.data.value.columns.map(getColName)
|
||
})),
|
||
resolvedIndexes,
|
||
tableDef,
|
||
...tableDef.isEvent ? { isEvent: true } : {}
|
||
};
|
||
}
|
||
var ModuleContext = class {
|
||
#compoundTypes = /* @__PURE__ */ new Map();
|
||
/**
|
||
* The global module definition that gets populated by calls to `reducer()` and lifecycle hooks.
|
||
*/
|
||
#moduleDef = {
|
||
typespace: { types: [] },
|
||
tables: [],
|
||
reducers: [],
|
||
types: [],
|
||
rowLevelSecurity: [],
|
||
schedules: [],
|
||
procedures: [],
|
||
views: [],
|
||
lifeCycleReducers: [],
|
||
caseConversionPolicy: { tag: "SnakeCase" },
|
||
explicitNames: { entries: [] }
|
||
};
|
||
get moduleDef() {
|
||
return this.#moduleDef;
|
||
}
|
||
rawModuleDefV10() {
|
||
const sections = [];
|
||
const push = (s) => {
|
||
if (s) sections.push(s);
|
||
};
|
||
const module = this.#moduleDef;
|
||
push(module.typespace && {
|
||
tag: "Typespace",
|
||
value: module.typespace
|
||
});
|
||
push(module.types && {
|
||
tag: "Types",
|
||
value: module.types
|
||
});
|
||
push(module.tables && {
|
||
tag: "Tables",
|
||
value: module.tables
|
||
});
|
||
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.schedules && {
|
||
tag: "Schedules",
|
||
value: module.schedules
|
||
});
|
||
push(module.lifeCycleReducers && {
|
||
tag: "LifeCycleReducers",
|
||
value: module.lifeCycleReducers
|
||
});
|
||
push(module.rowLevelSecurity && {
|
||
tag: "RowLevelSecurity",
|
||
value: module.rowLevelSecurity
|
||
});
|
||
push(module.explicitNames && {
|
||
tag: "ExplicitNames",
|
||
value: module.explicitNames
|
||
});
|
||
push(module.caseConversionPolicy && {
|
||
tag: "CaseConversionPolicy",
|
||
value: module.caseConversionPolicy
|
||
});
|
||
return { sections };
|
||
}
|
||
/**
|
||
* Set the case conversion policy for this module.
|
||
* Called by the settings mechanism.
|
||
*/
|
||
setCaseConversionPolicy(policy) {
|
||
this.#moduleDef.caseConversionPolicy = policy;
|
||
}
|
||
get typespace() {
|
||
return this.#moduleDef.typespace;
|
||
}
|
||
/**
|
||
* Resolves the actual type of a TypeBuilder by following its references until it reaches a non-ref type.
|
||
* @param typespace The typespace to resolve types against.
|
||
* @param typeBuilder The TypeBuilder to resolve.
|
||
* @returns The resolved algebraic type.
|
||
*/
|
||
resolveType(typeBuilder) {
|
||
let ty = typeBuilder.algebraicType;
|
||
while (ty.tag === "Ref") ty = this.typespace.types[ty.value];
|
||
return ty;
|
||
}
|
||
/**
|
||
* Adds a type to the module definition's typespace as a `Ref` if it is a named compound type (Product or Sum).
|
||
* Otherwise, returns the type as is.
|
||
* @param name
|
||
* @param ty
|
||
* @returns
|
||
*/
|
||
registerTypesRecursively(typeBuilder) {
|
||
if (typeBuilder instanceof ProductBuilder && !isUnit(typeBuilder) || typeBuilder instanceof SumBuilder || typeBuilder instanceof RowBuilder) return this.#registerCompoundTypeRecursively(typeBuilder);
|
||
else if (typeBuilder instanceof OptionBuilder) return new OptionBuilder(this.registerTypesRecursively(typeBuilder.value));
|
||
else if (typeBuilder instanceof ResultBuilder) return new ResultBuilder(this.registerTypesRecursively(typeBuilder.ok), this.registerTypesRecursively(typeBuilder.err));
|
||
else if (typeBuilder instanceof ArrayBuilder) return new ArrayBuilder(this.registerTypesRecursively(typeBuilder.element));
|
||
else return typeBuilder;
|
||
}
|
||
#registerCompoundTypeRecursively(typeBuilder) {
|
||
const ty = typeBuilder.algebraicType;
|
||
const name = typeBuilder.typeName;
|
||
if (name === void 0) throw new Error(`Missing type name for ${typeBuilder.constructor.name ?? "TypeBuilder"} ${JSON.stringify(typeBuilder)}`);
|
||
let r = this.#compoundTypes.get(ty);
|
||
if (r != null) return r;
|
||
const newTy = typeBuilder instanceof RowBuilder || typeBuilder instanceof ProductBuilder ? {
|
||
tag: "Product",
|
||
value: { elements: [] }
|
||
} : {
|
||
tag: "Sum",
|
||
value: { variants: [] }
|
||
};
|
||
r = new RefBuilder(this.#moduleDef.typespace.types.length);
|
||
this.#moduleDef.typespace.types.push(newTy);
|
||
this.#compoundTypes.set(ty, r);
|
||
if (typeBuilder instanceof RowBuilder) for (const [name2, elem] of Object.entries(typeBuilder.row)) newTy.value.elements.push({
|
||
name: name2,
|
||
algebraicType: this.registerTypesRecursively(elem.typeBuilder).algebraicType
|
||
});
|
||
else if (typeBuilder instanceof ProductBuilder) for (const [name2, elem] of Object.entries(typeBuilder.elements)) newTy.value.elements.push({
|
||
name: name2,
|
||
algebraicType: this.registerTypesRecursively(elem).algebraicType
|
||
});
|
||
else if (typeBuilder instanceof SumBuilder) for (const [name2, variant] of Object.entries(typeBuilder.variants)) newTy.value.variants.push({
|
||
name: name2,
|
||
algebraicType: this.registerTypesRecursively(variant).algebraicType
|
||
});
|
||
this.#moduleDef.types.push({
|
||
sourceName: splitName(name),
|
||
ty: r.ref,
|
||
customOrdering: true
|
||
});
|
||
return r;
|
||
}
|
||
};
|
||
function isUnit(typeBuilder) {
|
||
return typeBuilder.typeName == null && typeBuilder.algebraicType.value.elements.length === 0;
|
||
}
|
||
function splitName(name) {
|
||
const scope = name.split(".");
|
||
return {
|
||
sourceName: scope.pop(),
|
||
scope
|
||
};
|
||
}
|
||
var import_statuses = __toESM(require_statuses());
|
||
var Range = class {
|
||
#from;
|
||
#to;
|
||
constructor(from, to) {
|
||
this.#from = from ?? { tag: "unbounded" };
|
||
this.#to = to ?? { tag: "unbounded" };
|
||
}
|
||
get from() {
|
||
return this.#from;
|
||
}
|
||
get to() {
|
||
return this.#to;
|
||
}
|
||
};
|
||
function table(opts, row, ..._) {
|
||
const { name, public: isPublic = false, indexes: userIndexes = [], scheduled, event: isEvent = false } = opts;
|
||
const colIds = /* @__PURE__ */ new Map();
|
||
const colNameList = [];
|
||
if (!(row instanceof RowBuilder)) row = new RowBuilder(row);
|
||
row.algebraicType.value.elements.forEach((elem, i) => {
|
||
colIds.set(elem.name, i);
|
||
colNameList.push(elem.name);
|
||
});
|
||
const pk = [];
|
||
const indexes = [];
|
||
const constraints = [];
|
||
const sequences = [];
|
||
let scheduleAtCol;
|
||
const defaultValues = [];
|
||
for (const [name2, builder] of Object.entries(row.row)) {
|
||
const meta = builder.columnMetadata;
|
||
if (meta.isPrimaryKey) pk.push(colIds.get(name2));
|
||
const isUnique = meta.isUnique || meta.isPrimaryKey;
|
||
if (meta.indexType || isUnique) {
|
||
const algo = meta.indexType ?? "btree";
|
||
const id = colIds.get(name2);
|
||
let algorithm;
|
||
switch (algo) {
|
||
case "btree":
|
||
algorithm = RawIndexAlgorithm.BTree([id]);
|
||
break;
|
||
case "hash":
|
||
algorithm = RawIndexAlgorithm.Hash([id]);
|
||
break;
|
||
case "direct":
|
||
algorithm = RawIndexAlgorithm.Direct(id);
|
||
break;
|
||
}
|
||
indexes.push({
|
||
sourceName: void 0,
|
||
accessorName: name2,
|
||
algorithm
|
||
});
|
||
}
|
||
if (isUnique) constraints.push({
|
||
sourceName: void 0,
|
||
data: {
|
||
tag: "Unique",
|
||
value: { columns: [colIds.get(name2)] }
|
||
}
|
||
});
|
||
if (meta.isAutoIncrement) sequences.push({
|
||
sourceName: void 0,
|
||
start: void 0,
|
||
minValue: void 0,
|
||
maxValue: void 0,
|
||
column: colIds.get(name2),
|
||
increment: 1n
|
||
});
|
||
if (meta.defaultValue) {
|
||
const writer = new BinaryWriter(16);
|
||
builder.serialize(writer, meta.defaultValue);
|
||
defaultValues.push({
|
||
colId: colIds.get(name2),
|
||
value: writer.getBuffer()
|
||
});
|
||
}
|
||
if (scheduled) {
|
||
const algebraicType = builder.typeBuilder.algebraicType;
|
||
if (schedule_at_default.isScheduleAt(algebraicType)) scheduleAtCol = colIds.get(name2);
|
||
}
|
||
}
|
||
for (const indexOpts of userIndexes ?? []) {
|
||
const accessor = indexOpts.accessor;
|
||
if (typeof accessor !== "string" || accessor.length === 0) {
|
||
const tableLabel = name ?? "<unnamed>";
|
||
const indexLabel = indexOpts.name ?? "<unnamed>";
|
||
throw new TypeError(`Index '${indexLabel}' on table '${tableLabel}' must define a non-empty 'accessor'`);
|
||
}
|
||
let algorithm;
|
||
switch (indexOpts.algorithm) {
|
||
case "btree":
|
||
algorithm = {
|
||
tag: "BTree",
|
||
value: indexOpts.columns.map((c) => colIds.get(c))
|
||
};
|
||
break;
|
||
case "hash":
|
||
algorithm = {
|
||
tag: "Hash",
|
||
value: indexOpts.columns.map((c) => colIds.get(c))
|
||
};
|
||
break;
|
||
case "direct":
|
||
algorithm = {
|
||
tag: "Direct",
|
||
value: colIds.get(indexOpts.column)
|
||
};
|
||
break;
|
||
}
|
||
indexes.push({
|
||
sourceName: void 0,
|
||
accessorName: accessor,
|
||
algorithm,
|
||
canonicalName: indexOpts.name
|
||
});
|
||
}
|
||
for (const constraintOpts of opts.constraints ?? []) if (constraintOpts.constraint === "unique") {
|
||
const data = {
|
||
tag: "Unique",
|
||
value: { columns: constraintOpts.columns.map((c) => colIds.get(c)) }
|
||
};
|
||
constraints.push({
|
||
sourceName: constraintOpts.name,
|
||
data
|
||
});
|
||
continue;
|
||
}
|
||
const productType = row.algebraicType.value;
|
||
return {
|
||
rowType: row,
|
||
tableName: name,
|
||
rowSpacetimeType: productType,
|
||
tableDef: (ctx, accName) => {
|
||
const tableName = name ?? accName;
|
||
if (row.typeName === void 0) row.typeName = toPascalCase(tableName);
|
||
for (const index of indexes) {
|
||
const sourceName = index.sourceName = `${accName}_${(index.algorithm.tag === "Direct" ? [index.algorithm.value] : index.algorithm.value).map((i) => colNameList[i]).join("_")}_idx_${index.algorithm.tag.toLowerCase()}`;
|
||
const { canonicalName } = index;
|
||
if (canonicalName !== void 0) ctx.moduleDef.explicitNames.entries.push(ExplicitNameEntry.Index({
|
||
sourceName,
|
||
canonicalName
|
||
}));
|
||
}
|
||
return {
|
||
sourceName: accName,
|
||
productTypeRef: ctx.registerTypesRecursively(row).ref,
|
||
primaryKey: pk,
|
||
indexes,
|
||
constraints,
|
||
sequences,
|
||
tableType: { tag: "User" },
|
||
tableAccess: { tag: isPublic ? "Public" : "Private" },
|
||
defaultValues,
|
||
isEvent
|
||
};
|
||
},
|
||
idxs: userIndexes,
|
||
constraints,
|
||
schedule: scheduled && scheduleAtCol !== void 0 ? {
|
||
scheduleAtCol,
|
||
reducer: scheduled
|
||
} : void 0
|
||
};
|
||
}
|
||
var QueryBrand = Symbol("QueryBrand");
|
||
var isRowTypedQuery = (val) => !!val && typeof val === "object" && QueryBrand in val;
|
||
function toSql(q) {
|
||
return q.toSql();
|
||
}
|
||
var SemijoinImpl = class _SemijoinImpl {
|
||
constructor(sourceQuery, filterQuery, joinCondition) {
|
||
this.sourceQuery = sourceQuery;
|
||
this.filterQuery = filterQuery;
|
||
this.joinCondition = joinCondition;
|
||
if (sourceQuery.table.sourceName === filterQuery.table.sourceName) throw new Error("Cannot semijoin a table to itself");
|
||
}
|
||
[QueryBrand] = true;
|
||
type = "semijoin";
|
||
build() {
|
||
return this;
|
||
}
|
||
where(predicate) {
|
||
return new _SemijoinImpl(this.sourceQuery.where(predicate), this.filterQuery, this.joinCondition);
|
||
}
|
||
toSql() {
|
||
const left = this.filterQuery;
|
||
const right = this.sourceQuery;
|
||
const leftTable = quoteIdentifier(left.table.sourceName);
|
||
const rightTable = quoteIdentifier(right.table.sourceName);
|
||
let sql = `SELECT ${rightTable}.* FROM ${leftTable} JOIN ${rightTable} ON ${booleanExprToSql(this.joinCondition)}`;
|
||
const clauses = [];
|
||
if (left.whereClause) clauses.push(booleanExprToSql(left.whereClause));
|
||
if (right.whereClause) clauses.push(booleanExprToSql(right.whereClause));
|
||
if (clauses.length > 0) {
|
||
const whereSql = clauses.length === 1 ? clauses[0] : clauses.map(wrapInParens).join(" AND ");
|
||
sql += ` WHERE ${whereSql}`;
|
||
}
|
||
return sql;
|
||
}
|
||
};
|
||
var FromBuilder = class _FromBuilder {
|
||
constructor(table2, whereClause) {
|
||
this.table = table2;
|
||
this.whereClause = whereClause;
|
||
}
|
||
[QueryBrand] = true;
|
||
where(predicate) {
|
||
const newCondition = normalizePredicateExpr(predicate(this.table.cols));
|
||
const nextWhere = this.whereClause ? this.whereClause.and(newCondition) : newCondition;
|
||
return new _FromBuilder(this.table, nextWhere);
|
||
}
|
||
rightSemijoin(right, on) {
|
||
const sourceQuery = new _FromBuilder(right);
|
||
const joinCondition = on(this.table.indexedCols, right.indexedCols);
|
||
return new SemijoinImpl(sourceQuery, this, joinCondition);
|
||
}
|
||
leftSemijoin(right, on) {
|
||
const filterQuery = new _FromBuilder(right);
|
||
const joinCondition = on(this.table.indexedCols, right.indexedCols);
|
||
return new SemijoinImpl(this, filterQuery, joinCondition);
|
||
}
|
||
toSql() {
|
||
return renderSelectSqlWithJoins(this.table, this.whereClause);
|
||
}
|
||
build() {
|
||
return this;
|
||
}
|
||
};
|
||
var TableRefImpl = class {
|
||
[QueryBrand] = true;
|
||
type = "table";
|
||
sourceName;
|
||
accessorName;
|
||
cols;
|
||
indexedCols;
|
||
tableDef;
|
||
get columns() {
|
||
return this.tableDef.columns;
|
||
}
|
||
get indexes() {
|
||
return this.tableDef.indexes;
|
||
}
|
||
get rowType() {
|
||
return this.tableDef.rowType;
|
||
}
|
||
get constraints() {
|
||
return this.tableDef.constraints;
|
||
}
|
||
constructor(tableDef) {
|
||
this.sourceName = tableDef.sourceName;
|
||
this.accessorName = tableDef.accessorName;
|
||
this.cols = createRowExpr(tableDef);
|
||
this.indexedCols = this.cols;
|
||
this.tableDef = tableDef;
|
||
Object.freeze(this);
|
||
}
|
||
asFrom() {
|
||
return new FromBuilder(this);
|
||
}
|
||
rightSemijoin(other, on) {
|
||
return this.asFrom().rightSemijoin(other, on);
|
||
}
|
||
leftSemijoin(other, on) {
|
||
return this.asFrom().leftSemijoin(other, on);
|
||
}
|
||
build() {
|
||
return this.asFrom().build();
|
||
}
|
||
toSql() {
|
||
return this.asFrom().toSql();
|
||
}
|
||
where(predicate) {
|
||
return this.asFrom().where(predicate);
|
||
}
|
||
};
|
||
function createTableRefFromDef(tableDef) {
|
||
return new TableRefImpl(tableDef);
|
||
}
|
||
function makeQueryBuilder(schema2) {
|
||
const qb = /* @__PURE__ */ Object.create(null);
|
||
for (const table2 of Object.values(schema2.tables)) {
|
||
const ref = createTableRefFromDef(table2);
|
||
qb[table2.accessorName] = ref;
|
||
}
|
||
return Object.freeze(qb);
|
||
}
|
||
function createRowExpr(tableDef) {
|
||
const row = {};
|
||
for (const columnName of Object.keys(tableDef.columns)) {
|
||
const columnBuilder = tableDef.columns[columnName];
|
||
const column = new ColumnExpression(tableDef.sourceName, columnName, columnBuilder.typeBuilder.algebraicType, columnBuilder.columnMetadata.name);
|
||
row[columnName] = Object.freeze(column);
|
||
}
|
||
return Object.freeze(row);
|
||
}
|
||
function renderSelectSqlWithJoins(table2, where, extraClauses = []) {
|
||
const sql = `SELECT * FROM ${quoteIdentifier(table2.sourceName)}`;
|
||
const clauses = [];
|
||
if (where) clauses.push(booleanExprToSql(where));
|
||
clauses.push(...extraClauses);
|
||
if (clauses.length === 0) return sql;
|
||
return `${sql} WHERE ${clauses.length === 1 ? clauses[0] : clauses.map(wrapInParens).join(" AND ")}`;
|
||
}
|
||
var ColumnExpression = class {
|
||
type = "column";
|
||
column;
|
||
columnName;
|
||
table;
|
||
tsValueType;
|
||
spacetimeType;
|
||
constructor(table2, column, spacetimeType, columnName) {
|
||
this.table = table2;
|
||
this.column = column;
|
||
this.columnName = columnName || column;
|
||
this.spacetimeType = spacetimeType;
|
||
}
|
||
eq(x) {
|
||
return new BooleanExpr({
|
||
type: "eq",
|
||
left: this,
|
||
right: normalizeValue(x)
|
||
});
|
||
}
|
||
ne(x) {
|
||
return new BooleanExpr({
|
||
type: "ne",
|
||
left: this,
|
||
right: normalizeValue(x)
|
||
});
|
||
}
|
||
lt(x) {
|
||
return new BooleanExpr({
|
||
type: "lt",
|
||
left: this,
|
||
right: normalizeValue(x)
|
||
});
|
||
}
|
||
lte(x) {
|
||
return new BooleanExpr({
|
||
type: "lte",
|
||
left: this,
|
||
right: normalizeValue(x)
|
||
});
|
||
}
|
||
gt(x) {
|
||
return new BooleanExpr({
|
||
type: "gt",
|
||
left: this,
|
||
right: normalizeValue(x)
|
||
});
|
||
}
|
||
gte(x) {
|
||
return new BooleanExpr({
|
||
type: "gte",
|
||
left: this,
|
||
right: normalizeValue(x)
|
||
});
|
||
}
|
||
};
|
||
function literal(value) {
|
||
return {
|
||
type: "literal",
|
||
value
|
||
};
|
||
}
|
||
function normalizeValue(val) {
|
||
if (val.type === "literal") return val;
|
||
if (typeof val === "object" && val != null && "type" in val && val.type === "column") return val;
|
||
return literal(val);
|
||
}
|
||
function normalizePredicateExpr(value) {
|
||
if (value instanceof BooleanExpr) return value;
|
||
if (typeof value === "boolean") return new BooleanExpr({
|
||
type: "eq",
|
||
left: literal(value),
|
||
right: literal(true)
|
||
});
|
||
return new BooleanExpr({
|
||
type: "eq",
|
||
left: value,
|
||
right: literal(true)
|
||
});
|
||
}
|
||
var BooleanExpr = class _BooleanExpr {
|
||
constructor(data) {
|
||
this.data = data;
|
||
}
|
||
and(other) {
|
||
return new _BooleanExpr({
|
||
type: "and",
|
||
clauses: [this.data, other.data]
|
||
});
|
||
}
|
||
or(other) {
|
||
return new _BooleanExpr({
|
||
type: "or",
|
||
clauses: [this.data, other.data]
|
||
});
|
||
}
|
||
not() {
|
||
return new _BooleanExpr({
|
||
type: "not",
|
||
clause: this.data
|
||
});
|
||
}
|
||
};
|
||
function booleanExprToSql(expr, tableAlias) {
|
||
const data = expr instanceof BooleanExpr ? expr.data : expr;
|
||
switch (data.type) {
|
||
case "eq": return `${valueExprToSql(data.left)} = ${valueExprToSql(data.right)}`;
|
||
case "ne": return `${valueExprToSql(data.left)} <> ${valueExprToSql(data.right)}`;
|
||
case "gt": return `${valueExprToSql(data.left)} > ${valueExprToSql(data.right)}`;
|
||
case "gte": return `${valueExprToSql(data.left)} >= ${valueExprToSql(data.right)}`;
|
||
case "lt": return `${valueExprToSql(data.left)} < ${valueExprToSql(data.right)}`;
|
||
case "lte": return `${valueExprToSql(data.left)} <= ${valueExprToSql(data.right)}`;
|
||
case "and": return data.clauses.map((c) => booleanExprToSql(c)).map(wrapInParens).join(" AND ");
|
||
case "or": return data.clauses.map((c) => booleanExprToSql(c)).map(wrapInParens).join(" OR ");
|
||
case "not": return `NOT ${wrapInParens(booleanExprToSql(data.clause))}`;
|
||
}
|
||
}
|
||
function wrapInParens(sql) {
|
||
return `(${sql})`;
|
||
}
|
||
function valueExprToSql(expr, tableAlias) {
|
||
if (isLiteralExpr(expr)) return literalValueToSql(expr.value);
|
||
const table2 = expr.table;
|
||
return `${quoteIdentifier(table2)}.${quoteIdentifier(expr.columnName)}`;
|
||
}
|
||
function literalValueToSql(value) {
|
||
if (value === null || value === void 0) return "NULL";
|
||
if (value instanceof Identity || value instanceof ConnectionId) return `0x${value.toHexString()}`;
|
||
if (value instanceof Timestamp) return `'${value.toISOString()}'`;
|
||
switch (typeof value) {
|
||
case "number":
|
||
case "bigint": return String(value);
|
||
case "boolean": return value ? "TRUE" : "FALSE";
|
||
case "string": return `'${value.replace(/'/g, "''")}'`;
|
||
default: return `'${JSON.stringify(value).replace(/'/g, "''")}'`;
|
||
}
|
||
}
|
||
function quoteIdentifier(name) {
|
||
return `"${name.replace(/"/g, "\"\"")}"`;
|
||
}
|
||
function isLiteralExpr(expr) {
|
||
return expr.type === "literal";
|
||
}
|
||
function makeViewExport(ctx, opts, params, ret, fn) {
|
||
const viewExport = fn.bind();
|
||
viewExport[exportContext] = ctx;
|
||
viewExport[registerExport] = (ctx2, exportName) => {
|
||
registerView(ctx2, opts, exportName, false, params, ret, fn);
|
||
};
|
||
return viewExport;
|
||
}
|
||
function makeAnonViewExport(ctx, opts, params, ret, fn) {
|
||
const viewExport = fn.bind();
|
||
viewExport[exportContext] = ctx;
|
||
viewExport[registerExport] = (ctx2, exportName) => {
|
||
registerView(ctx2, opts, exportName, true, params, ret, fn);
|
||
};
|
||
return viewExport;
|
||
}
|
||
function registerView(ctx, opts, exportName, anon, params, ret, fn) {
|
||
const paramsBuilder = new RowBuilder(params, toPascalCase(exportName));
|
||
let returnType = ctx.registerTypesRecursively(ret).algebraicType;
|
||
const { typespace } = ctx;
|
||
const { value: paramType } = ctx.resolveType(ctx.registerTypesRecursively(paramsBuilder));
|
||
ctx.moduleDef.views.push({
|
||
sourceName: exportName,
|
||
index: (anon ? ctx.anonViews : ctx.views).length,
|
||
isPublic: opts.public,
|
||
isAnonymous: anon,
|
||
params: paramType,
|
||
returnType
|
||
});
|
||
if (opts.name != null) ctx.moduleDef.explicitNames.entries.push({
|
||
tag: "Function",
|
||
value: {
|
||
sourceName: exportName,
|
||
canonicalName: opts.name
|
||
}
|
||
});
|
||
if (returnType.tag == "Sum") {
|
||
const originalFn = fn;
|
||
fn = ((ctx2, args) => {
|
||
const ret2 = originalFn(ctx2, args);
|
||
return ret2 == null ? [] : [ret2];
|
||
});
|
||
returnType = AlgebraicType.Array(returnType.value.variants[0].algebraicType);
|
||
}
|
||
(anon ? ctx.anonViews : ctx.views).push({
|
||
fn,
|
||
deserializeParams: ProductType.makeDeserializer(paramType, typespace),
|
||
serializeReturn: AlgebraicType.makeSerializer(returnType, typespace),
|
||
returnTypeBaseSize: bsatnBaseSize(typespace, returnType)
|
||
});
|
||
}
|
||
var SenderError = class extends Error {
|
||
constructor(message) {
|
||
super(message);
|
||
}
|
||
get name() {
|
||
return "SenderError";
|
||
}
|
||
};
|
||
var SpacetimeHostError = class extends Error {
|
||
constructor(message) {
|
||
super(message);
|
||
}
|
||
get name() {
|
||
return "SpacetimeHostError";
|
||
}
|
||
};
|
||
var errorData = {
|
||
HostCallFailure: 1,
|
||
NotInTransaction: 2,
|
||
BsatnDecodeError: 3,
|
||
NoSuchTable: 4,
|
||
NoSuchIndex: 5,
|
||
NoSuchIter: 6,
|
||
NoSuchConsoleTimer: 7,
|
||
NoSuchBytes: 8,
|
||
NoSpace: 9,
|
||
BufferTooSmall: 11,
|
||
UniqueAlreadyExists: 12,
|
||
ScheduleAtDelayTooLong: 13,
|
||
IndexNotUnique: 14,
|
||
NoSuchRow: 15,
|
||
AutoIncOverflow: 16,
|
||
WouldBlockTransaction: 17,
|
||
TransactionNotAnonymous: 18,
|
||
TransactionIsReadOnly: 19,
|
||
TransactionIsMut: 20,
|
||
HttpError: 21
|
||
};
|
||
function mapEntries(x, f) {
|
||
return Object.fromEntries(Object.entries(x).map(([k, v]) => [k, f(k, v)]));
|
||
}
|
||
var errnoToClass = /* @__PURE__ */ new Map();
|
||
var errors = Object.freeze(mapEntries(errorData, (name, code) => {
|
||
const cls = Object.defineProperty(class extends SpacetimeHostError {
|
||
get name() {
|
||
return name;
|
||
}
|
||
}, "name", {
|
||
value: name,
|
||
writable: false
|
||
});
|
||
errnoToClass.set(code, cls);
|
||
return cls;
|
||
}));
|
||
function getErrorConstructor(code) {
|
||
return errnoToClass.get(code) ?? SpacetimeHostError;
|
||
}
|
||
var SBigInt = typeof BigInt !== "undefined" ? BigInt : void 0;
|
||
var One = typeof BigInt !== "undefined" ? BigInt(1) : void 0;
|
||
var ThirtyTwo = typeof BigInt !== "undefined" ? BigInt(32) : void 0;
|
||
var NumValues = typeof BigInt !== "undefined" ? BigInt(4294967296) : void 0;
|
||
function unsafeUniformBigIntDistribution(from, to, rng) {
|
||
var diff = to - from + One;
|
||
var FinalNumValues = NumValues;
|
||
var NumIterations = 1;
|
||
while (FinalNumValues < diff) {
|
||
FinalNumValues <<= ThirtyTwo;
|
||
++NumIterations;
|
||
}
|
||
var value = generateNext(NumIterations, rng);
|
||
if (value < diff) return value + from;
|
||
if (value + diff < FinalNumValues) return value % diff + from;
|
||
var MaxAcceptedRandom = FinalNumValues - FinalNumValues % diff;
|
||
while (value >= MaxAcceptedRandom) value = generateNext(NumIterations, rng);
|
||
return value % diff + from;
|
||
}
|
||
function generateNext(NumIterations, rng) {
|
||
var value = SBigInt(rng.unsafeNext() + 2147483648);
|
||
for (var num = 1; num < NumIterations; ++num) {
|
||
var out = rng.unsafeNext();
|
||
value = (value << ThirtyTwo) + SBigInt(out + 2147483648);
|
||
}
|
||
return value;
|
||
}
|
||
function unsafeUniformIntDistributionInternal(rangeSize, rng) {
|
||
var MaxAllowed = rangeSize > 2 ? ~~(4294967296 / rangeSize) * rangeSize : 4294967296;
|
||
var deltaV = rng.unsafeNext() + 2147483648;
|
||
while (deltaV >= MaxAllowed) deltaV = rng.unsafeNext() + 2147483648;
|
||
return deltaV % rangeSize;
|
||
}
|
||
function fromNumberToArrayInt64(out, n) {
|
||
if (n < 0) {
|
||
var posN = -n;
|
||
out.sign = -1;
|
||
out.data[0] = ~~(posN / 4294967296);
|
||
out.data[1] = posN >>> 0;
|
||
} else {
|
||
out.sign = 1;
|
||
out.data[0] = ~~(n / 4294967296);
|
||
out.data[1] = n >>> 0;
|
||
}
|
||
return out;
|
||
}
|
||
function substractArrayInt64(out, arrayIntA, arrayIntB) {
|
||
var lowA = arrayIntA.data[1];
|
||
var highA = arrayIntA.data[0];
|
||
var signA = arrayIntA.sign;
|
||
var lowB = arrayIntB.data[1];
|
||
var highB = arrayIntB.data[0];
|
||
var signB = arrayIntB.sign;
|
||
out.sign = 1;
|
||
if (signA === 1 && signB === -1) {
|
||
var low_1 = lowA + lowB;
|
||
var high = highA + highB + (low_1 > 4294967295 ? 1 : 0);
|
||
out.data[0] = high >>> 0;
|
||
out.data[1] = low_1 >>> 0;
|
||
return out;
|
||
}
|
||
var lowFirst = lowA;
|
||
var highFirst = highA;
|
||
var lowSecond = lowB;
|
||
var highSecond = highB;
|
||
if (signA === -1) {
|
||
lowFirst = lowB;
|
||
highFirst = highB;
|
||
lowSecond = lowA;
|
||
highSecond = highA;
|
||
}
|
||
var reminderLow = 0;
|
||
var low = lowFirst - lowSecond;
|
||
if (low < 0) {
|
||
reminderLow = 1;
|
||
low = low >>> 0;
|
||
}
|
||
out.data[0] = highFirst - highSecond - reminderLow;
|
||
out.data[1] = low;
|
||
return out;
|
||
}
|
||
function unsafeUniformArrayIntDistributionInternal(out, rangeSize, rng) {
|
||
var rangeLength = rangeSize.length;
|
||
while (true) {
|
||
for (var index = 0; index !== rangeLength; ++index) out[index] = unsafeUniformIntDistributionInternal(index === 0 ? rangeSize[0] + 1 : 4294967296, rng);
|
||
for (var index = 0; index !== rangeLength; ++index) {
|
||
var current = out[index];
|
||
var currentInRange = rangeSize[index];
|
||
if (current < currentInRange) return out;
|
||
else if (current > currentInRange) break;
|
||
}
|
||
}
|
||
}
|
||
var safeNumberMaxSafeInteger = Number.MAX_SAFE_INTEGER;
|
||
var sharedA = {
|
||
sign: 1,
|
||
data: [0, 0]
|
||
};
|
||
var sharedB = {
|
||
sign: 1,
|
||
data: [0, 0]
|
||
};
|
||
var sharedC = {
|
||
sign: 1,
|
||
data: [0, 0]
|
||
};
|
||
var sharedData = [0, 0];
|
||
function uniformLargeIntInternal(from, to, rangeSize, rng) {
|
||
var rangeSizeArrayIntValue = rangeSize <= safeNumberMaxSafeInteger ? fromNumberToArrayInt64(sharedC, rangeSize) : substractArrayInt64(sharedC, fromNumberToArrayInt64(sharedA, to), fromNumberToArrayInt64(sharedB, from));
|
||
if (rangeSizeArrayIntValue.data[1] === 4294967295) {
|
||
rangeSizeArrayIntValue.data[0] += 1;
|
||
rangeSizeArrayIntValue.data[1] = 0;
|
||
} else rangeSizeArrayIntValue.data[1] += 1;
|
||
unsafeUniformArrayIntDistributionInternal(sharedData, rangeSizeArrayIntValue.data, rng);
|
||
return sharedData[0] * 4294967296 + sharedData[1] + from;
|
||
}
|
||
function unsafeUniformIntDistribution(from, to, rng) {
|
||
var rangeSize = to - from;
|
||
if (rangeSize <= 4294967295) return unsafeUniformIntDistributionInternal(rangeSize + 1, rng) + from;
|
||
return uniformLargeIntInternal(from, to, rangeSize, rng);
|
||
}
|
||
var XoroShiro128Plus = (function() {
|
||
function XoroShiro128Plus2(s01, s00, s11, s10) {
|
||
this.s01 = s01;
|
||
this.s00 = s00;
|
||
this.s11 = s11;
|
||
this.s10 = s10;
|
||
}
|
||
XoroShiro128Plus2.prototype.clone = function() {
|
||
return new XoroShiro128Plus2(this.s01, this.s00, this.s11, this.s10);
|
||
};
|
||
XoroShiro128Plus2.prototype.next = function() {
|
||
var nextRng = new XoroShiro128Plus2(this.s01, this.s00, this.s11, this.s10);
|
||
return [nextRng.unsafeNext(), nextRng];
|
||
};
|
||
XoroShiro128Plus2.prototype.unsafeNext = function() {
|
||
var out = this.s00 + this.s10 | 0;
|
||
var a0 = this.s10 ^ this.s00;
|
||
var a1 = this.s11 ^ this.s01;
|
||
var s00 = this.s00;
|
||
var s01 = this.s01;
|
||
this.s00 = s00 << 24 ^ s01 >>> 8 ^ a0 ^ a0 << 16;
|
||
this.s01 = s01 << 24 ^ s00 >>> 8 ^ a1 ^ (a1 << 16 | a0 >>> 16);
|
||
this.s10 = a1 << 5 ^ a0 >>> 27;
|
||
this.s11 = a0 << 5 ^ a1 >>> 27;
|
||
return out;
|
||
};
|
||
XoroShiro128Plus2.prototype.jump = function() {
|
||
var nextRng = new XoroShiro128Plus2(this.s01, this.s00, this.s11, this.s10);
|
||
nextRng.unsafeJump();
|
||
return nextRng;
|
||
};
|
||
XoroShiro128Plus2.prototype.unsafeJump = function() {
|
||
var ns01 = 0;
|
||
var ns00 = 0;
|
||
var ns11 = 0;
|
||
var ns10 = 0;
|
||
var jump = [
|
||
3639956645,
|
||
3750757012,
|
||
1261568508,
|
||
386426335
|
||
];
|
||
for (var i = 0; i !== 4; ++i) for (var mask = 1; mask; mask <<= 1) {
|
||
if (jump[i] & mask) {
|
||
ns01 ^= this.s01;
|
||
ns00 ^= this.s00;
|
||
ns11 ^= this.s11;
|
||
ns10 ^= this.s10;
|
||
}
|
||
this.unsafeNext();
|
||
}
|
||
this.s01 = ns01;
|
||
this.s00 = ns00;
|
||
this.s11 = ns11;
|
||
this.s10 = ns10;
|
||
};
|
||
XoroShiro128Plus2.prototype.getState = function() {
|
||
return [
|
||
this.s01,
|
||
this.s00,
|
||
this.s11,
|
||
this.s10
|
||
];
|
||
};
|
||
return XoroShiro128Plus2;
|
||
})();
|
||
function fromState(state) {
|
||
if (!(state.length === 4)) throw new Error("The state must have been produced by a xoroshiro128plus RandomGenerator");
|
||
return new XoroShiro128Plus(state[0], state[1], state[2], state[3]);
|
||
}
|
||
var xoroshiro128plus = Object.assign(function(seed) {
|
||
return new XoroShiro128Plus(-1, ~seed, seed | 0, 0);
|
||
}, { fromState });
|
||
var { asUintN } = BigInt;
|
||
function pcg32(state) {
|
||
state = asUintN(64, state * 6364136223846793005n + 11634580027462260723n);
|
||
const xorshifted = Number(asUintN(32, (state >> 18n ^ state) >> 27n));
|
||
const rot = Number(asUintN(32, state >> 59n));
|
||
return xorshifted >> rot | xorshifted << 32 - rot;
|
||
}
|
||
function generateFloat64(rng) {
|
||
const g1 = unsafeUniformIntDistribution(0, (1 << 26) - 1, rng);
|
||
const g2 = unsafeUniformIntDistribution(0, (1 << 27) - 1, rng);
|
||
return (g1 * Math.pow(2, 27) + g2) * Math.pow(2, -53);
|
||
}
|
||
function makeRandom(seed) {
|
||
const rng = xoroshiro128plus(pcg32(seed.microsSinceUnixEpoch));
|
||
const random = () => generateFloat64(rng);
|
||
random.fill = (array) => {
|
||
const elem = array.at(0);
|
||
if (typeof elem === "bigint") {
|
||
const upper = (1n << BigInt(array.BYTES_PER_ELEMENT * 8)) - 1n;
|
||
for (let i = 0; i < array.length; i++) array[i] = unsafeUniformBigIntDistribution(0n, upper, rng);
|
||
} else if (typeof elem === "number") {
|
||
const upper = (1 << array.BYTES_PER_ELEMENT * 8) - 1;
|
||
for (let i = 0; i < array.length; i++) array[i] = unsafeUniformIntDistribution(0, upper, rng);
|
||
}
|
||
return array;
|
||
};
|
||
random.uint32 = () => rng.unsafeNext();
|
||
random.integerInRange = (min, max) => unsafeUniformIntDistribution(min, max, rng);
|
||
random.bigintInRange = (min, max) => unsafeUniformBigIntDistribution(min, max, rng);
|
||
return random;
|
||
}
|
||
var { freeze } = Object;
|
||
var sys = _syscalls2_0;
|
||
function parseJsonObject(json) {
|
||
let value;
|
||
try {
|
||
value = JSON.parse(json);
|
||
} catch {
|
||
throw new Error("Invalid JSON: failed to parse string");
|
||
}
|
||
if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error("Expected a JSON object at the top level");
|
||
return value;
|
||
}
|
||
var JwtClaimsImpl = class {
|
||
/**
|
||
* Creates a new JwtClaims instance.
|
||
* @param rawPayload The JWT payload as a raw JSON string.
|
||
* @param identity The identity for this JWT. We are only taking this because we don't have a blake3 implementation (which we need to compute it).
|
||
*/
|
||
constructor(rawPayload, identity) {
|
||
this.rawPayload = rawPayload;
|
||
this.fullPayload = parseJsonObject(rawPayload);
|
||
this._identity = identity;
|
||
}
|
||
fullPayload;
|
||
_identity;
|
||
get identity() {
|
||
return this._identity;
|
||
}
|
||
get subject() {
|
||
return this.fullPayload["sub"];
|
||
}
|
||
get issuer() {
|
||
return this.fullPayload["iss"];
|
||
}
|
||
get audience() {
|
||
const aud = this.fullPayload["aud"];
|
||
if (aud == null) return [];
|
||
return typeof aud === "string" ? [aud] : aud;
|
||
}
|
||
};
|
||
var AuthCtxImpl = class _AuthCtxImpl {
|
||
isInternal;
|
||
_jwtSource;
|
||
_initializedJWT = false;
|
||
_jwtClaims;
|
||
_senderIdentity;
|
||
constructor(opts) {
|
||
this.isInternal = opts.isInternal;
|
||
this._jwtSource = opts.jwtSource;
|
||
this._senderIdentity = opts.senderIdentity;
|
||
}
|
||
_initializeJWT() {
|
||
if (this._initializedJWT) return;
|
||
this._initializedJWT = true;
|
||
const token = this._jwtSource();
|
||
if (!token) this._jwtClaims = null;
|
||
else this._jwtClaims = new JwtClaimsImpl(token, this._senderIdentity);
|
||
Object.freeze(this);
|
||
}
|
||
/** Lazily compute whether a JWT exists and is parseable. */
|
||
get hasJWT() {
|
||
this._initializeJWT();
|
||
return this._jwtClaims !== null;
|
||
}
|
||
/** Lazily parse the JwtClaims only when accessed. */
|
||
get jwt() {
|
||
this._initializeJWT();
|
||
return this._jwtClaims;
|
||
}
|
||
/** Create a context representing internal (non-user) requests. */
|
||
static internal() {
|
||
return new _AuthCtxImpl({
|
||
isInternal: true,
|
||
jwtSource: () => null,
|
||
senderIdentity: Identity.zero()
|
||
});
|
||
}
|
||
/** If there is a connection id, look up the JWT payload from the system tables. */
|
||
static fromSystemTables(connectionId, sender) {
|
||
if (connectionId === null) return new _AuthCtxImpl({
|
||
isInternal: false,
|
||
jwtSource: () => null,
|
||
senderIdentity: sender
|
||
});
|
||
return new _AuthCtxImpl({
|
||
isInternal: false,
|
||
jwtSource: () => {
|
||
const payloadBuf = sys.get_jwt_payload(connectionId.__connection_id__);
|
||
if (payloadBuf.length === 0) return null;
|
||
return new TextDecoder().decode(payloadBuf);
|
||
},
|
||
senderIdentity: sender
|
||
});
|
||
}
|
||
};
|
||
var ReducerCtxImpl = class ReducerCtx {
|
||
#identity;
|
||
#senderAuth;
|
||
#uuidCounter;
|
||
#random;
|
||
sender;
|
||
timestamp;
|
||
connectionId;
|
||
db;
|
||
constructor(sender, timestamp, connectionId, dbView) {
|
||
Object.seal(this);
|
||
this.sender = sender;
|
||
this.timestamp = timestamp;
|
||
this.connectionId = connectionId;
|
||
this.db = dbView;
|
||
}
|
||
/** Reset the `ReducerCtx` to be used for a new transaction */
|
||
static reset(me, sender, timestamp, connectionId) {
|
||
me.sender = sender;
|
||
me.timestamp = timestamp;
|
||
me.connectionId = connectionId;
|
||
me.#uuidCounter = void 0;
|
||
me.#senderAuth = void 0;
|
||
}
|
||
get identity() {
|
||
return this.#identity ??= new Identity(sys.identity());
|
||
}
|
||
get senderAuth() {
|
||
return this.#senderAuth ??= AuthCtxImpl.fromSystemTables(this.connectionId, this.sender);
|
||
}
|
||
get random() {
|
||
return this.#random ??= makeRandom(this.timestamp);
|
||
}
|
||
/**
|
||
* Create a new random {@link Uuid} `v4` using this `ReducerCtx`'s RNG.
|
||
*/
|
||
newUuidV4() {
|
||
const bytes = this.random.fill(new Uint8Array(16));
|
||
return Uuid.fromRandomBytesV4(bytes);
|
||
}
|
||
/**
|
||
* Create a new sortable {@link Uuid} `v7` using this `ReducerCtx`'s RNG, counter,
|
||
* and timestamp.
|
||
*/
|
||
newUuidV7() {
|
||
const bytes = this.random.fill(new Uint8Array(4));
|
||
const counter = this.#uuidCounter ??= { value: 0 };
|
||
return Uuid.fromCounterV7(counter, this.timestamp, bytes);
|
||
}
|
||
};
|
||
var callUserFunction = function __spacetimedb_end_short_backtrace(fn, ...args) {
|
||
return fn(...args);
|
||
};
|
||
var makeHooks = (schema2) => new ModuleHooksImpl(schema2);
|
||
var ModuleHooksImpl = class {
|
||
#schema;
|
||
#dbView_;
|
||
#reducerArgsDeserializers;
|
||
/** Cache the `ReducerCtx` object to avoid allocating anew for ever reducer call. */
|
||
#reducerCtx_;
|
||
constructor(schema2) {
|
||
this.#schema = schema2;
|
||
this.#reducerArgsDeserializers = schema2.moduleDef.reducers.map(({ params }) => ProductType.makeDeserializer(params, schema2.typespace));
|
||
}
|
||
get #dbView() {
|
||
return this.#dbView_ ??= freeze(Object.fromEntries(Object.values(this.#schema.schemaType.tables).map((table2) => [table2.accessorName, makeTableView(this.#schema.typespace, table2.tableDef)])));
|
||
}
|
||
get #reducerCtx() {
|
||
return this.#reducerCtx_ ??= new ReducerCtxImpl(Identity.zero(), Timestamp.UNIX_EPOCH, null, this.#dbView);
|
||
}
|
||
__describe_module__() {
|
||
const writer = new BinaryWriter(128);
|
||
RawModuleDef.serialize(writer, RawModuleDef.V10(this.#schema.rawModuleDefV10()));
|
||
return writer.getBuffer();
|
||
}
|
||
__get_error_constructor__(code) {
|
||
return getErrorConstructor(code);
|
||
}
|
||
get __sender_error_class__() {
|
||
return SenderError;
|
||
}
|
||
__call_reducer__(reducerId, sender, connId, timestamp, argsBuf) {
|
||
const moduleCtx = this.#schema;
|
||
const deserializeArgs = this.#reducerArgsDeserializers[reducerId];
|
||
BINARY_READER.reset(argsBuf);
|
||
const args = deserializeArgs(BINARY_READER);
|
||
const senderIdentity = new Identity(sender);
|
||
const ctx = this.#reducerCtx;
|
||
ReducerCtxImpl.reset(ctx, senderIdentity, new Timestamp(timestamp), ConnectionId.nullIfZero(new ConnectionId(connId)));
|
||
callUserFunction(moduleCtx.reducers[reducerId], ctx, args);
|
||
}
|
||
__call_view__(id, sender, argsBuf) {
|
||
const moduleCtx = this.#schema;
|
||
const { fn, deserializeParams, serializeReturn, returnTypeBaseSize } = moduleCtx.views[id];
|
||
const ret = callUserFunction(fn, freeze({
|
||
sender: new Identity(sender),
|
||
db: this.#dbView,
|
||
from: makeQueryBuilder(moduleCtx.schemaType)
|
||
}), deserializeParams(new BinaryReader(argsBuf)));
|
||
const retBuf = new BinaryWriter(returnTypeBaseSize);
|
||
if (isRowTypedQuery(ret)) {
|
||
const query = toSql(ret);
|
||
ViewResultHeader.serialize(retBuf, ViewResultHeader.RawSql(query));
|
||
} else {
|
||
ViewResultHeader.serialize(retBuf, ViewResultHeader.RowData);
|
||
serializeReturn(retBuf, ret);
|
||
}
|
||
return { data: retBuf.getBuffer() };
|
||
}
|
||
__call_view_anon__(id, argsBuf) {
|
||
const moduleCtx = this.#schema;
|
||
const { fn, deserializeParams, serializeReturn, returnTypeBaseSize } = moduleCtx.anonViews[id];
|
||
const ret = callUserFunction(fn, freeze({
|
||
db: this.#dbView,
|
||
from: makeQueryBuilder(moduleCtx.schemaType)
|
||
}), deserializeParams(new BinaryReader(argsBuf)));
|
||
const retBuf = new BinaryWriter(returnTypeBaseSize);
|
||
if (isRowTypedQuery(ret)) {
|
||
const query = toSql(ret);
|
||
ViewResultHeader.serialize(retBuf, ViewResultHeader.RawSql(query));
|
||
} else {
|
||
ViewResultHeader.serialize(retBuf, ViewResultHeader.RowData);
|
||
serializeReturn(retBuf, ret);
|
||
}
|
||
return { data: retBuf.getBuffer() };
|
||
}
|
||
__call_procedure__(id, sender, connection_id, timestamp, args) {
|
||
return callProcedure(this.#schema, id, new Identity(sender), ConnectionId.nullIfZero(new ConnectionId(connection_id)), new Timestamp(timestamp), args, () => this.#dbView);
|
||
}
|
||
};
|
||
var BINARY_WRITER = new BinaryWriter(0);
|
||
var BINARY_READER = new BinaryReader(new Uint8Array());
|
||
function makeTableView(typespace, table2) {
|
||
const table_id = sys.table_id_from_name(table2.sourceName);
|
||
const rowType = typespace.types[table2.productTypeRef];
|
||
if (rowType.tag !== "Product") throw "impossible";
|
||
const serializeRow = AlgebraicType.makeSerializer(rowType, typespace);
|
||
const deserializeRow = AlgebraicType.makeDeserializer(rowType, typespace);
|
||
const sequences = table2.sequences.map((seq) => {
|
||
const col = rowType.value.elements[seq.column];
|
||
const colType = col.algebraicType;
|
||
let sequenceTrigger;
|
||
switch (colType.tag) {
|
||
case "U8":
|
||
case "I8":
|
||
case "U16":
|
||
case "I16":
|
||
case "U32":
|
||
case "I32":
|
||
sequenceTrigger = 0;
|
||
break;
|
||
case "U64":
|
||
case "I64":
|
||
case "U128":
|
||
case "I128":
|
||
case "U256":
|
||
case "I256":
|
||
sequenceTrigger = 0n;
|
||
break;
|
||
default: throw new TypeError("invalid sequence type");
|
||
}
|
||
return {
|
||
colName: col.name,
|
||
sequenceTrigger,
|
||
deserialize: AlgebraicType.makeDeserializer(colType, typespace)
|
||
};
|
||
});
|
||
const hasAutoIncrement = sequences.length > 0;
|
||
const iter = () => tableIterator(sys.datastore_table_scan_bsatn(table_id), deserializeRow);
|
||
const integrateGeneratedColumns = hasAutoIncrement ? (row, ret_buf) => {
|
||
BINARY_READER.reset(ret_buf);
|
||
for (const { colName, deserialize, sequenceTrigger } of sequences) if (row[colName] === sequenceTrigger) row[colName] = deserialize(BINARY_READER);
|
||
} : null;
|
||
const tableMethods = {
|
||
count: () => sys.datastore_table_row_count(table_id),
|
||
iter,
|
||
[Symbol.iterator]: () => iter(),
|
||
insert: (row) => {
|
||
const buf = LEAF_BUF;
|
||
BINARY_WRITER.reset(buf);
|
||
serializeRow(BINARY_WRITER, row);
|
||
sys.datastore_insert_bsatn(table_id, buf.buffer, BINARY_WRITER.offset);
|
||
const ret = { ...row };
|
||
integrateGeneratedColumns?.(ret, buf.view);
|
||
return ret;
|
||
},
|
||
delete: (row) => {
|
||
const buf = LEAF_BUF;
|
||
BINARY_WRITER.reset(buf);
|
||
BINARY_WRITER.writeU32(1);
|
||
serializeRow(BINARY_WRITER, row);
|
||
return sys.datastore_delete_all_by_eq_bsatn(table_id, buf.buffer, BINARY_WRITER.offset) > 0;
|
||
}
|
||
};
|
||
const tableView = Object.assign(/* @__PURE__ */ Object.create(null), tableMethods);
|
||
for (const indexDef of table2.indexes) {
|
||
const accessorName = indexDef.accessorName;
|
||
const index_id = sys.index_id_from_name(indexDef.sourceName);
|
||
let column_ids;
|
||
let isHashIndex = false;
|
||
switch (indexDef.algorithm.tag) {
|
||
case "Hash":
|
||
isHashIndex = true;
|
||
column_ids = indexDef.algorithm.value;
|
||
break;
|
||
case "BTree":
|
||
column_ids = indexDef.algorithm.value;
|
||
break;
|
||
case "Direct":
|
||
column_ids = [indexDef.algorithm.value];
|
||
break;
|
||
}
|
||
const numColumns = column_ids.length;
|
||
const columnSet = new Set(column_ids);
|
||
const isUnique = table2.constraints.filter((x) => x.data.tag === "Unique").some((x) => columnSet.isSubsetOf(new Set(x.data.value.columns)));
|
||
const isPrimaryKey = isUnique && column_ids.length === table2.primaryKey.length && column_ids.every((id, i) => table2.primaryKey[i] === id);
|
||
const indexSerializers = column_ids.map((id) => AlgebraicType.makeSerializer(rowType.value.elements[id].algebraicType, typespace));
|
||
const serializePoint = (buffer, colVal) => {
|
||
BINARY_WRITER.reset(buffer);
|
||
for (let i = 0; i < numColumns; i++) indexSerializers[i](BINARY_WRITER, colVal[i]);
|
||
return BINARY_WRITER.offset;
|
||
};
|
||
const serializeSingleElement = numColumns === 1 ? indexSerializers[0] : null;
|
||
const serializeSinglePoint = serializeSingleElement && ((buffer, colVal) => {
|
||
BINARY_WRITER.reset(buffer);
|
||
serializeSingleElement(BINARY_WRITER, colVal);
|
||
return BINARY_WRITER.offset;
|
||
});
|
||
let index;
|
||
if (isUnique && serializeSinglePoint) {
|
||
const base = {
|
||
find: (colVal) => {
|
||
const buf = LEAF_BUF;
|
||
const point_len = serializeSinglePoint(buf, colVal);
|
||
return tableIterateOne(sys.datastore_index_scan_point_bsatn(index_id, buf.buffer, point_len), deserializeRow);
|
||
},
|
||
delete: (colVal) => {
|
||
const buf = LEAF_BUF;
|
||
const point_len = serializeSinglePoint(buf, colVal);
|
||
return sys.datastore_delete_by_index_scan_point_bsatn(index_id, buf.buffer, point_len) > 0;
|
||
}
|
||
};
|
||
if (isPrimaryKey) base.update = (row) => {
|
||
const buf = LEAF_BUF;
|
||
BINARY_WRITER.reset(buf);
|
||
serializeRow(BINARY_WRITER, row);
|
||
sys.datastore_update_bsatn(table_id, index_id, buf.buffer, BINARY_WRITER.offset);
|
||
integrateGeneratedColumns?.(row, buf.view);
|
||
return row;
|
||
};
|
||
index = base;
|
||
} else if (isUnique) {
|
||
const base = {
|
||
find: (colVal) => {
|
||
if (colVal.length !== numColumns) throw new TypeError("wrong number of elements");
|
||
const buf = LEAF_BUF;
|
||
const point_len = serializePoint(buf, colVal);
|
||
return tableIterateOne(sys.datastore_index_scan_point_bsatn(index_id, buf.buffer, point_len), deserializeRow);
|
||
},
|
||
delete: (colVal) => {
|
||
if (colVal.length !== numColumns) throw new TypeError("wrong number of elements");
|
||
const buf = LEAF_BUF;
|
||
const point_len = serializePoint(buf, colVal);
|
||
return sys.datastore_delete_by_index_scan_point_bsatn(index_id, buf.buffer, point_len) > 0;
|
||
}
|
||
};
|
||
if (isPrimaryKey) base.update = (row) => {
|
||
const buf = LEAF_BUF;
|
||
BINARY_WRITER.reset(buf);
|
||
serializeRow(BINARY_WRITER, row);
|
||
sys.datastore_update_bsatn(table_id, index_id, buf.buffer, BINARY_WRITER.offset);
|
||
integrateGeneratedColumns?.(row, buf.view);
|
||
return row;
|
||
};
|
||
index = base;
|
||
} else if (serializeSinglePoint) {
|
||
const rawIndex = {
|
||
filter: (range) => {
|
||
const buf = LEAF_BUF;
|
||
const point_len = serializeSinglePoint(buf, range);
|
||
return tableIterator(sys.datastore_index_scan_point_bsatn(index_id, buf.buffer, point_len), deserializeRow);
|
||
},
|
||
delete: (range) => {
|
||
const buf = LEAF_BUF;
|
||
const point_len = serializeSinglePoint(buf, range);
|
||
return sys.datastore_delete_by_index_scan_point_bsatn(index_id, buf.buffer, point_len);
|
||
}
|
||
};
|
||
if (isHashIndex) index = rawIndex;
|
||
else index = rawIndex;
|
||
} else if (isHashIndex) index = {
|
||
filter: (range) => {
|
||
const buf = LEAF_BUF;
|
||
const point_len = serializePoint(buf, range);
|
||
return tableIterator(sys.datastore_index_scan_point_bsatn(index_id, buf.buffer, point_len), deserializeRow);
|
||
},
|
||
delete: (range) => {
|
||
const buf = LEAF_BUF;
|
||
const point_len = serializePoint(buf, range);
|
||
return sys.datastore_delete_by_index_scan_point_bsatn(index_id, buf.buffer, point_len);
|
||
}
|
||
};
|
||
else {
|
||
const serializeRange = (buffer, range) => {
|
||
if (range.length > numColumns) throw new TypeError("too many elements");
|
||
BINARY_WRITER.reset(buffer);
|
||
const writer = BINARY_WRITER;
|
||
const prefix_elems = range.length - 1;
|
||
for (let i = 0; i < prefix_elems; i++) indexSerializers[i](writer, range[i]);
|
||
const rstartOffset = writer.offset;
|
||
const term = range[range.length - 1];
|
||
const serializeTerm = indexSerializers[range.length - 1];
|
||
if (term instanceof Range) {
|
||
const writeBound = (bound) => {
|
||
writer.writeU8({
|
||
included: 0,
|
||
excluded: 1,
|
||
unbounded: 2
|
||
}[bound.tag]);
|
||
if (bound.tag !== "unbounded") serializeTerm(writer, bound.value);
|
||
};
|
||
writeBound(term.from);
|
||
const rstartLen = writer.offset - rstartOffset;
|
||
writeBound(term.to);
|
||
return [
|
||
rstartOffset,
|
||
prefix_elems,
|
||
rstartLen,
|
||
writer.offset - rstartLen
|
||
];
|
||
} else {
|
||
writer.writeU8(0);
|
||
serializeTerm(writer, term);
|
||
return [
|
||
rstartOffset,
|
||
prefix_elems,
|
||
writer.offset,
|
||
0
|
||
];
|
||
}
|
||
};
|
||
index = {
|
||
filter: (range) => {
|
||
if (range.length === numColumns) {
|
||
const buf = LEAF_BUF;
|
||
const point_len = serializePoint(buf, range);
|
||
return tableIterator(sys.datastore_index_scan_point_bsatn(index_id, buf.buffer, point_len), deserializeRow);
|
||
} else {
|
||
const buf = LEAF_BUF;
|
||
const args = serializeRange(buf, range);
|
||
return tableIterator(sys.datastore_index_scan_range_bsatn(index_id, buf.buffer, ...args), deserializeRow);
|
||
}
|
||
},
|
||
delete: (range) => {
|
||
if (range.length === numColumns) {
|
||
const buf = LEAF_BUF;
|
||
const point_len = serializePoint(buf, range);
|
||
return sys.datastore_delete_by_index_scan_point_bsatn(index_id, buf.buffer, point_len);
|
||
} else {
|
||
const buf = LEAF_BUF;
|
||
const args = serializeRange(buf, range);
|
||
return sys.datastore_delete_by_index_scan_range_bsatn(index_id, buf.buffer, ...args);
|
||
}
|
||
}
|
||
};
|
||
}
|
||
if (Object.hasOwn(tableView, accessorName)) freeze(Object.assign(tableView[accessorName], index));
|
||
else tableView[accessorName] = freeze(index);
|
||
}
|
||
return freeze(tableView);
|
||
}
|
||
function* tableIterator(id, deserialize) {
|
||
using iter = new IteratorHandle(id);
|
||
const iterBuf = takeBuf();
|
||
try {
|
||
let amt;
|
||
while (amt = iter.advance(iterBuf)) {
|
||
const reader = new BinaryReader(iterBuf.view);
|
||
while (reader.offset < amt) yield deserialize(reader);
|
||
}
|
||
} finally {
|
||
returnBuf(iterBuf);
|
||
}
|
||
}
|
||
function tableIterateOne(id, deserialize) {
|
||
const buf = LEAF_BUF;
|
||
if (advanceIterRaw(id, buf) !== 0) {
|
||
BINARY_READER.reset(buf.view);
|
||
return deserialize(BINARY_READER);
|
||
}
|
||
return null;
|
||
}
|
||
function advanceIterRaw(id, buf) {
|
||
while (true) try {
|
||
return 0 | sys.row_iter_bsatn_advance(id, buf.buffer);
|
||
} catch (e) {
|
||
if (e && typeof e === "object" && hasOwn(e, "__buffer_too_small__")) {
|
||
buf.grow(e.__buffer_too_small__);
|
||
continue;
|
||
}
|
||
throw e;
|
||
}
|
||
}
|
||
var DEFAULT_BUFFER_CAPACITY = 32 * 1024 * 2;
|
||
var ITER_BUFS = [new ResizableBuffer(DEFAULT_BUFFER_CAPACITY)];
|
||
var ITER_BUF_COUNT = 1;
|
||
function takeBuf() {
|
||
return ITER_BUF_COUNT ? ITER_BUFS[--ITER_BUF_COUNT] : new ResizableBuffer(DEFAULT_BUFFER_CAPACITY);
|
||
}
|
||
function returnBuf(buf) {
|
||
ITER_BUFS[ITER_BUF_COUNT++] = buf;
|
||
}
|
||
var LEAF_BUF = new ResizableBuffer(DEFAULT_BUFFER_CAPACITY);
|
||
var IteratorHandle = class _IteratorHandle {
|
||
#id;
|
||
static #finalizationRegistry = new FinalizationRegistry(sys.row_iter_bsatn_close);
|
||
constructor(id) {
|
||
this.#id = id;
|
||
_IteratorHandle.#finalizationRegistry.register(this, id, this);
|
||
}
|
||
/** Unregister this object with the finalization registry and return the id */
|
||
#detach() {
|
||
const id = this.#id;
|
||
this.#id = -1;
|
||
_IteratorHandle.#finalizationRegistry.unregister(this);
|
||
return id;
|
||
}
|
||
/** Call `row_iter_bsatn_advance`, returning 0 if this iterator has been exhausted. */
|
||
advance(buf) {
|
||
if (this.#id === -1) return 0;
|
||
const ret = advanceIterRaw(this.#id, buf);
|
||
if (ret <= 0) this.#detach();
|
||
return ret < 0 ? -ret : ret;
|
||
}
|
||
[Symbol.dispose]() {
|
||
if (this.#id >= 0) {
|
||
const id = this.#detach();
|
||
sys.row_iter_bsatn_close(id);
|
||
}
|
||
}
|
||
};
|
||
var { freeze: freeze2 } = Object;
|
||
var textEncoder = new TextEncoder();
|
||
var textDecoder = new TextDecoder("utf-8");
|
||
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 = { 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 uri = "" + url;
|
||
const request = freeze2({
|
||
method,
|
||
headers,
|
||
timeout: init.timeout,
|
||
uri,
|
||
version: { tag: "Http11" }
|
||
});
|
||
const requestBuf = new BinaryWriter(requestBaseSize);
|
||
HttpRequest.serialize(requestBuf, request);
|
||
const body = init.body == null ? new Uint8Array() : typeof init.body === "string" ? init.body : new Uint8Array(init.body);
|
||
const [responseBuf, responseBody] = sys.procedure_http_request(requestBuf.getBuffer(), body);
|
||
const response = HttpResponse.deserialize(new BinaryReader(responseBuf));
|
||
return SyncResponse[makeResponse](responseBody, {
|
||
type: "basic",
|
||
url: uri,
|
||
status: response.code,
|
||
statusText: (0, import_statuses.default)(response.code),
|
||
headers: new Headers(),
|
||
aborted: false
|
||
});
|
||
}
|
||
freeze2(fetch);
|
||
var httpClient = freeze2({ fetch });
|
||
function makeProcedureExport(ctx, opts, params, ret, fn) {
|
||
const name = opts?.name;
|
||
const procedureExport = (...args) => fn(...args);
|
||
procedureExport[exportContext] = ctx;
|
||
procedureExport[registerExport] = (ctx2, exportName) => {
|
||
registerProcedure(ctx2, name ?? exportName, params, ret, fn);
|
||
ctx2.functionExports.set(procedureExport, name ?? exportName);
|
||
};
|
||
return procedureExport;
|
||
}
|
||
var TransactionCtxImpl = class TransactionCtx extends ReducerCtxImpl {};
|
||
function registerProcedure(ctx, exportName, params, ret, fn, opts) {
|
||
ctx.defineFunction(exportName);
|
||
const paramsType = { elements: Object.entries(params).map(([n, c]) => ({
|
||
name: n,
|
||
algebraicType: ctx.registerTypesRecursively("typeBuilder" in c ? c.typeBuilder : c).algebraicType
|
||
})) };
|
||
const returnType = ctx.registerTypesRecursively(ret).algebraicType;
|
||
ctx.moduleDef.procedures.push({
|
||
sourceName: exportName,
|
||
params: paramsType,
|
||
returnType,
|
||
visibility: FunctionVisibility.ClientCallable
|
||
});
|
||
const { typespace } = ctx;
|
||
ctx.procedures.push({
|
||
fn,
|
||
deserializeArgs: ProductType.makeDeserializer(paramsType, typespace),
|
||
serializeReturn: AlgebraicType.makeSerializer(returnType, typespace),
|
||
returnTypeBaseSize: bsatnBaseSize(typespace, returnType)
|
||
});
|
||
}
|
||
function callProcedure(moduleCtx, id, sender, connectionId, timestamp, argsBuf, dbView) {
|
||
const { fn, deserializeArgs, serializeReturn, returnTypeBaseSize } = moduleCtx.procedures[id];
|
||
const args = deserializeArgs(new BinaryReader(argsBuf));
|
||
const ret = callUserFunction(fn, new ProcedureCtxImpl(sender, timestamp, connectionId, dbView), args);
|
||
const retBuf = new BinaryWriter(returnTypeBaseSize);
|
||
serializeReturn(retBuf, ret);
|
||
return retBuf.getBuffer();
|
||
}
|
||
var ProcedureCtxImpl = class ProcedureCtx {
|
||
constructor(sender, timestamp, connectionId, dbView) {
|
||
this.sender = sender;
|
||
this.timestamp = timestamp;
|
||
this.connectionId = connectionId;
|
||
this.#dbView = dbView;
|
||
}
|
||
#identity;
|
||
#uuidCounter;
|
||
#random;
|
||
#dbView;
|
||
get identity() {
|
||
return this.#identity ??= new Identity(sys.identity());
|
||
}
|
||
get random() {
|
||
return this.#random ??= makeRandom(this.timestamp);
|
||
}
|
||
get http() {
|
||
return httpClient;
|
||
}
|
||
withTx(body) {
|
||
const run = () => {
|
||
const timestamp = sys.procedure_start_mut_tx();
|
||
try {
|
||
return body(new TransactionCtxImpl(this.sender, new Timestamp(timestamp), this.connectionId, this.#dbView()));
|
||
} 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 });
|
||
}
|
||
}
|
||
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 makeReducerExport(ctx, opts, params, fn, lifecycle) {
|
||
const reducerExport = (...args) => fn(...args);
|
||
reducerExport[exportContext] = ctx;
|
||
reducerExport[registerExport] = (ctx2, exportName) => {
|
||
registerReducer(ctx2, exportName, params, fn, opts, lifecycle);
|
||
ctx2.functionExports.set(reducerExport, exportName);
|
||
};
|
||
return reducerExport;
|
||
}
|
||
function registerReducer(ctx, exportName, params, fn, opts, lifecycle) {
|
||
ctx.defineFunction(exportName);
|
||
if (!(params instanceof RowBuilder)) params = new RowBuilder(params);
|
||
if (params.typeName === void 0) params.typeName = toPascalCase(exportName);
|
||
const ref = ctx.registerTypesRecursively(params);
|
||
const paramsType = ctx.resolveType(ref).value;
|
||
const isLifecycle = lifecycle != null;
|
||
ctx.moduleDef.reducers.push({
|
||
sourceName: exportName,
|
||
params: paramsType,
|
||
visibility: FunctionVisibility.ClientCallable,
|
||
okReturnType: AlgebraicType.Product({ elements: [] }),
|
||
errReturnType: AlgebraicType.String
|
||
});
|
||
if (opts?.name != null) ctx.moduleDef.explicitNames.entries.push({
|
||
tag: "Function",
|
||
value: {
|
||
sourceName: exportName,
|
||
canonicalName: opts.name
|
||
}
|
||
});
|
||
if (isLifecycle) ctx.moduleDef.lifeCycleReducers.push({
|
||
lifecycleSpec: lifecycle,
|
||
functionName: exportName
|
||
});
|
||
if (!fn.name) Object.defineProperty(fn, "name", {
|
||
value: exportName,
|
||
writable: false
|
||
});
|
||
ctx.reducers.push(fn);
|
||
}
|
||
var SchemaInner = class extends ModuleContext {
|
||
schemaType;
|
||
existingFunctions = /* @__PURE__ */ new Set();
|
||
reducers = [];
|
||
procedures = [];
|
||
views = [];
|
||
anonViews = [];
|
||
/**
|
||
* Maps ReducerExport objects to the name of the reducer.
|
||
* Used for resolving the reducers of scheduled tables.
|
||
*/
|
||
functionExports = /* @__PURE__ */ new Map();
|
||
pendingSchedules = [];
|
||
constructor(getSchemaType) {
|
||
super();
|
||
this.schemaType = getSchemaType(this);
|
||
}
|
||
defineFunction(name) {
|
||
if (this.existingFunctions.has(name)) throw new TypeError(`There is already a reducer or procedure with the name '${name}'`);
|
||
this.existingFunctions.add(name);
|
||
}
|
||
resolveSchedules() {
|
||
for (const { reducer, scheduleAtCol, tableName } of this.pendingSchedules) {
|
||
const functionName = this.functionExports.get(reducer());
|
||
if (functionName === void 0) {
|
||
const msg = `Table ${tableName} defines a schedule, but it seems like the associated function was not exported.`;
|
||
throw new TypeError(msg);
|
||
}
|
||
this.moduleDef.schedules.push({
|
||
sourceName: void 0,
|
||
tableName,
|
||
scheduleAtCol,
|
||
functionName
|
||
});
|
||
}
|
||
}
|
||
};
|
||
var Schema = class {
|
||
#ctx;
|
||
constructor(ctx) {
|
||
this.#ctx = ctx;
|
||
}
|
||
[moduleHooks](exports) {
|
||
const registeredSchema = this.#ctx;
|
||
for (const [name, moduleExport] of Object.entries(exports)) {
|
||
if (name === "default") continue;
|
||
if (!isModuleExport(moduleExport)) throw new TypeError("exporting something that is not a spacetime export");
|
||
checkExportContext(moduleExport, registeredSchema);
|
||
moduleExport[registerExport](registeredSchema, name);
|
||
}
|
||
registeredSchema.resolveSchedules();
|
||
return makeHooks(registeredSchema);
|
||
}
|
||
get schemaType() {
|
||
return this.#ctx.schemaType;
|
||
}
|
||
get moduleDef() {
|
||
return this.#ctx.moduleDef;
|
||
}
|
||
get typespace() {
|
||
return this.#ctx.typespace;
|
||
}
|
||
reducer(...args) {
|
||
let opts, params = {}, fn;
|
||
switch (args.length) {
|
||
case 1:
|
||
[fn] = args;
|
||
break;
|
||
case 2: {
|
||
let arg1;
|
||
[arg1, fn] = args;
|
||
if (typeof arg1.name === "string") opts = arg1;
|
||
else params = arg1;
|
||
break;
|
||
}
|
||
case 3:
|
||
[opts, params, fn] = args;
|
||
break;
|
||
}
|
||
return makeReducerExport(this.#ctx, opts, params, fn);
|
||
}
|
||
init(...args) {
|
||
let opts, fn;
|
||
switch (args.length) {
|
||
case 1:
|
||
[fn] = args;
|
||
break;
|
||
case 2:
|
||
[opts, fn] = args;
|
||
break;
|
||
}
|
||
return makeReducerExport(this.#ctx, opts, {}, fn, Lifecycle.Init);
|
||
}
|
||
clientConnected(...args) {
|
||
let opts, fn;
|
||
switch (args.length) {
|
||
case 1:
|
||
[fn] = args;
|
||
break;
|
||
case 2:
|
||
[opts, fn] = args;
|
||
break;
|
||
}
|
||
return makeReducerExport(this.#ctx, opts, {}, fn, Lifecycle.OnConnect);
|
||
}
|
||
clientDisconnected(...args) {
|
||
let opts, fn;
|
||
switch (args.length) {
|
||
case 1:
|
||
[fn] = args;
|
||
break;
|
||
case 2:
|
||
[opts, fn] = args;
|
||
break;
|
||
}
|
||
return makeReducerExport(this.#ctx, opts, {}, fn, Lifecycle.OnDisconnect);
|
||
}
|
||
view(opts, ret, fn) {
|
||
return makeViewExport(this.#ctx, opts, {}, ret, fn);
|
||
}
|
||
anonymousView(opts, ret, fn) {
|
||
return makeAnonViewExport(this.#ctx, opts, {}, ret, fn);
|
||
}
|
||
procedure(...args) {
|
||
let opts, params = {}, ret, fn;
|
||
switch (args.length) {
|
||
case 2:
|
||
[ret, fn] = args;
|
||
break;
|
||
case 3: {
|
||
let arg1;
|
||
[arg1, ret, fn] = args;
|
||
if (typeof arg1.name === "string") opts = arg1;
|
||
else params = arg1;
|
||
break;
|
||
}
|
||
case 4:
|
||
[opts, params, ret, fn] = args;
|
||
break;
|
||
}
|
||
return makeProcedureExport(this.#ctx, opts, params, ret, fn);
|
||
}
|
||
/**
|
||
* 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.
|
||
*/
|
||
exportGroup(exports) {
|
||
return {
|
||
[exportContext]: this.#ctx,
|
||
[registerExport](ctx, _exportName) {
|
||
for (const [exportName, moduleExport] of Object.entries(exports)) {
|
||
checkExportContext(moduleExport, ctx);
|
||
moduleExport[registerExport](ctx, exportName);
|
||
}
|
||
}
|
||
};
|
||
}
|
||
clientVisibilityFilter = { sql: (filter) => ({
|
||
[exportContext]: this.#ctx,
|
||
[registerExport](ctx, _exportName) {
|
||
ctx.moduleDef.rowLevelSecurity.push({ sql: filter });
|
||
}
|
||
}) };
|
||
};
|
||
var registerExport = Symbol("SpacetimeDB.registerExport");
|
||
var exportContext = Symbol("SpacetimeDB.exportContext");
|
||
function isModuleExport(x) {
|
||
return (typeof x === "function" || typeof x === "object") && x !== null && registerExport in x;
|
||
}
|
||
function checkExportContext(exp, schema2) {
|
||
if (exp[exportContext] != null && exp[exportContext] !== schema2) throw new TypeError("multiple schemas are not supported");
|
||
}
|
||
function schema(tables, moduleSettings) {
|
||
return new Schema(new SchemaInner((ctx2) => {
|
||
if (moduleSettings?.CASE_CONVERSION_POLICY != null) ctx2.setCaseConversionPolicy(moduleSettings.CASE_CONVERSION_POLICY);
|
||
const tableSchemas = {};
|
||
for (const [accName, table2] of Object.entries(tables)) {
|
||
const tableDef = table2.tableDef(ctx2, accName);
|
||
tableSchemas[accName] = tableToSchema(accName, table2, tableDef);
|
||
ctx2.moduleDef.tables.push(tableDef);
|
||
if (table2.schedule) ctx2.pendingSchedules.push({
|
||
...table2.schedule,
|
||
tableName: tableDef.sourceName
|
||
});
|
||
if (table2.tableName) ctx2.moduleDef.explicitNames.entries.push({
|
||
tag: "Table",
|
||
value: {
|
||
sourceName: accName,
|
||
canonicalName: table2.tableName
|
||
}
|
||
});
|
||
}
|
||
return { tables: tableSchemas };
|
||
}));
|
||
}
|
||
var import_object_inspect = __toESM(require_object_inspect());
|
||
var fmtLog = (...data) => data.map((x) => typeof x === "string" ? x : (0, import_object_inspect.default)(x)).join(" ");
|
||
var console_level_error = 0;
|
||
var console_level_warn = 1;
|
||
var console_level_info = 2;
|
||
var console_level_debug = 3;
|
||
var console_level_trace = 4;
|
||
var timerMap = /* @__PURE__ */ new Map();
|
||
var console2 = {
|
||
__proto__: {},
|
||
[Symbol.toStringTag]: "console",
|
||
assert: (condition = false, ...data) => {
|
||
if (!condition) sys.console_log(console_level_error, fmtLog(...data));
|
||
},
|
||
clear: () => {},
|
||
debug: (...data) => {
|
||
sys.console_log(console_level_debug, fmtLog(...data));
|
||
},
|
||
error: (...data) => {
|
||
sys.console_log(console_level_error, fmtLog(...data));
|
||
},
|
||
info: (...data) => {
|
||
sys.console_log(console_level_info, fmtLog(...data));
|
||
},
|
||
log: (...data) => {
|
||
sys.console_log(console_level_info, fmtLog(...data));
|
||
},
|
||
table: (tabularData, _properties) => {
|
||
sys.console_log(console_level_info, fmtLog(tabularData));
|
||
},
|
||
trace: (...data) => {
|
||
sys.console_log(console_level_trace, fmtLog(...data));
|
||
},
|
||
warn: (...data) => {
|
||
sys.console_log(console_level_warn, fmtLog(...data));
|
||
},
|
||
dir: (_item, _options) => {},
|
||
dirxml: (..._data) => {},
|
||
count: (_label = "default") => {},
|
||
countReset: (_label = "default") => {},
|
||
group: (..._data) => {},
|
||
groupCollapsed: (..._data) => {},
|
||
groupEnd: () => {},
|
||
time: (label = "default") => {
|
||
if (timerMap.has(label)) {
|
||
sys.console_log(console_level_warn, `Timer '${label}' already exists.`);
|
||
return;
|
||
}
|
||
timerMap.set(label, sys.console_timer_start(label));
|
||
},
|
||
timeLog: (label = "default", ...data) => {
|
||
sys.console_log(console_level_info, fmtLog(label, ...data));
|
||
},
|
||
timeEnd: (label = "default") => {
|
||
const spanId = timerMap.get(label);
|
||
if (spanId === void 0) {
|
||
sys.console_log(console_level_warn, `Timer '${label}' does not exist.`);
|
||
return;
|
||
}
|
||
sys.console_timer_end(spanId);
|
||
timerMap.delete(label);
|
||
},
|
||
timeStamp: () => {},
|
||
profile: () => {},
|
||
profileEnd: () => {}
|
||
};
|
||
globalThis.console = console2;
|
||
|
||
//#endregion
|
||
//#region src/index.ts
|
||
const channel_kind = t.enum("ChannelKind", {
|
||
text: t.unit(),
|
||
voice: t.unit()
|
||
});
|
||
const spacetimedb = schema({
|
||
user: table({
|
||
name: "user",
|
||
public: true
|
||
}, {
|
||
identity: t.identity().primaryKey(),
|
||
name: t.string().optional(),
|
||
online: t.bool(),
|
||
issuer: t.string().optional(),
|
||
subject: t.string().optional(),
|
||
username: t.string().optional(),
|
||
password: t.string().optional()
|
||
}),
|
||
server: table({
|
||
name: "server",
|
||
public: true
|
||
}, {
|
||
id: t.u64().primaryKey().autoInc(),
|
||
name: t.string(),
|
||
owner: t.identity().optional()
|
||
}),
|
||
channel: table({
|
||
name: "channel",
|
||
public: true,
|
||
indexes: [{
|
||
accessor: "by_server_id",
|
||
algorithm: "btree",
|
||
columns: ["server_id"]
|
||
}]
|
||
}, {
|
||
id: t.u64().primaryKey().autoInc(),
|
||
server_id: t.u64(),
|
||
name: t.string(),
|
||
kind: channel_kind
|
||
}),
|
||
voice_state: table({
|
||
name: "voice_state",
|
||
public: true,
|
||
indexes: [{
|
||
accessor: "by_channel_id",
|
||
algorithm: "btree",
|
||
columns: ["channel_id"]
|
||
}]
|
||
}, {
|
||
identity: t.identity().primaryKey(),
|
||
channel_id: t.u64()
|
||
}),
|
||
sdp_offer: table({
|
||
name: "sdp_offer",
|
||
public: true,
|
||
indexes: [{
|
||
accessor: "by_receiver",
|
||
algorithm: "btree",
|
||
columns: ["receiver"]
|
||
}]
|
||
}, {
|
||
sender: t.identity(),
|
||
receiver: t.identity(),
|
||
sdp: t.string(),
|
||
channel_id: t.u64()
|
||
}),
|
||
sdp_answer: table({
|
||
name: "sdp_answer",
|
||
public: true,
|
||
indexes: [{
|
||
accessor: "by_receiver",
|
||
algorithm: "btree",
|
||
columns: ["receiver"]
|
||
}]
|
||
}, {
|
||
sender: t.identity(),
|
||
receiver: t.identity(),
|
||
sdp: t.string(),
|
||
channel_id: t.u64()
|
||
}),
|
||
ice_candidate: table({
|
||
name: "ice_candidate",
|
||
public: true,
|
||
indexes: [{
|
||
accessor: "by_receiver",
|
||
algorithm: "btree",
|
||
columns: ["receiver"]
|
||
}]
|
||
}, {
|
||
sender: t.identity(),
|
||
receiver: t.identity(),
|
||
candidate: t.string(),
|
||
channel_id: t.u64()
|
||
}),
|
||
thread: table({
|
||
name: "thread",
|
||
public: true,
|
||
indexes: [{
|
||
accessor: "by_channel_id",
|
||
algorithm: "btree",
|
||
columns: ["channel_id"]
|
||
}]
|
||
}, {
|
||
id: t.u64().primaryKey().autoInc(),
|
||
channel_id: t.u64(),
|
||
parent_message_id: t.u64().unique(),
|
||
name: t.string()
|
||
}),
|
||
message: table({
|
||
name: "message",
|
||
public: true,
|
||
indexes: [{
|
||
accessor: "by_channel_id",
|
||
algorithm: "btree",
|
||
columns: ["channel_id"]
|
||
}, {
|
||
accessor: "by_thread_id",
|
||
algorithm: "btree",
|
||
columns: ["thread_id"]
|
||
}]
|
||
}, {
|
||
id: t.u64().primaryKey().autoInc(),
|
||
sender: t.identity(),
|
||
sent: t.timestamp(),
|
||
text: t.string(),
|
||
channel_id: t.u64(),
|
||
thread_id: t.u64().optional()
|
||
})
|
||
});
|
||
function validateName(name) {
|
||
if (!name || name.trim().length === 0) throw new SenderError("Names must not be empty");
|
||
}
|
||
const set_name = spacetimedb.reducer({ name: t.string() }, (ctx, { name }) => {
|
||
validateName(name);
|
||
const user = ctx.db.user.identity.find(ctx.sender);
|
||
if (!user) throw new SenderError("Cannot set name for unknown user");
|
||
ctx.db.user.identity.update({
|
||
...user,
|
||
name
|
||
});
|
||
});
|
||
const register = spacetimedb.reducer({
|
||
username: t.string(),
|
||
password: t.string()
|
||
}, (ctx, { username, password }) => {
|
||
validateName(username);
|
||
if (!password || password.length < 4) throw new SenderError("Password must be at least 4 characters");
|
||
for (const u of ctx.db.user.iter()) if (u.username === username) throw new SenderError("Username already taken");
|
||
const user = ctx.db.user.identity.find(ctx.sender);
|
||
if (user) ctx.db.user.identity.update({
|
||
...user,
|
||
username,
|
||
password,
|
||
name: user.name || username
|
||
});
|
||
else ctx.db.user.insert({
|
||
identity: ctx.sender,
|
||
username,
|
||
password,
|
||
name: username,
|
||
online: true,
|
||
issuer: void 0,
|
||
subject: void 0
|
||
});
|
||
});
|
||
const login = spacetimedb.reducer({
|
||
username: t.string(),
|
||
password: t.string()
|
||
}, (ctx, { username, password }) => {
|
||
let foundUser = null;
|
||
for (const u of ctx.db.user.iter()) if (u.username === username && u.password === password) {
|
||
foundUser = u;
|
||
break;
|
||
}
|
||
if (!foundUser) throw new SenderError("Invalid username or password");
|
||
const currentIdentityUser = ctx.db.user.identity.find(ctx.sender);
|
||
if (currentIdentityUser && currentIdentityUser.identity.toHexString() !== foundUser.identity.toHexString()) ctx.db.user.identity.delete(ctx.sender);
|
||
if (foundUser.identity.toHexString() !== ctx.sender.toHexString()) {
|
||
ctx.db.user.identity.delete(foundUser.identity);
|
||
ctx.db.user.insert({
|
||
...foundUser,
|
||
identity: ctx.sender,
|
||
online: true
|
||
});
|
||
} else ctx.db.user.identity.update({
|
||
...foundUser,
|
||
online: true
|
||
});
|
||
});
|
||
const create_server = spacetimedb.reducer({ name: t.string() }, (ctx, { name }) => {
|
||
validateName(name);
|
||
const user = ctx.db.user.identity.find(ctx.sender);
|
||
if (!user || !user.username && !user.subject) throw new SenderError("You must be logged in to create a server");
|
||
const s = ctx.db.server.insert({
|
||
id: 0n,
|
||
name,
|
||
owner: ctx.sender
|
||
});
|
||
ctx.db.channel.insert({
|
||
id: 0n,
|
||
server_id: s.id,
|
||
name: "general",
|
||
kind: { tag: "text" }
|
||
});
|
||
ctx.db.channel.insert({
|
||
id: 0n,
|
||
server_id: s.id,
|
||
name: "Voice General",
|
||
kind: { tag: "voice" }
|
||
});
|
||
});
|
||
const create_channel = spacetimedb.reducer({
|
||
name: t.string(),
|
||
serverId: t.u64(),
|
||
isVoice: t.bool()
|
||
}, (ctx, { name, serverId, isVoice }) => {
|
||
validateName(name);
|
||
const user = ctx.db.user.identity.find(ctx.sender);
|
||
if (!user || !user.username && !user.subject) throw new SenderError("You must be logged in to create a channel");
|
||
if (!ctx.db.server.id.find(serverId)) throw new SenderError("Server not found");
|
||
ctx.db.channel.insert({
|
||
id: 0n,
|
||
server_id: serverId,
|
||
name,
|
||
kind: isVoice ? { tag: "voice" } : { tag: "text" }
|
||
});
|
||
});
|
||
const join_voice = spacetimedb.reducer({ channelId: t.u64() }, (ctx, { channelId }) => {
|
||
const user = ctx.db.user.identity.find(ctx.sender);
|
||
if (!user || !user.username && !user.subject) throw new SenderError("You must be logged in to join voice");
|
||
const chan = ctx.db.channel.id.find(channelId);
|
||
if (!chan || chan.kind.tag !== "voice") throw new SenderError("Invalid voice channel");
|
||
const existing = ctx.db.voice_state.identity.find(ctx.sender);
|
||
if (existing) {
|
||
if (existing.channel_id !== channelId) {
|
||
clearSignalingForUser(ctx, ctx.sender);
|
||
ctx.db.voice_state.identity.update({
|
||
identity: ctx.sender,
|
||
channel_id: channelId
|
||
});
|
||
}
|
||
} else ctx.db.voice_state.insert({
|
||
identity: ctx.sender,
|
||
channel_id: channelId
|
||
});
|
||
});
|
||
const leave_voice = spacetimedb.reducer((ctx) => {
|
||
ctx.db.voice_state.identity.delete(ctx.sender);
|
||
clearSignalingForUser(ctx, ctx.sender);
|
||
});
|
||
const send_sdp_offer = spacetimedb.reducer({
|
||
receiver: t.identity(),
|
||
sdp: t.string(),
|
||
channelId: t.u64()
|
||
}, (ctx, { receiver, sdp, channelId }) => {
|
||
ctx.db.sdp_offer.insert({
|
||
sender: ctx.sender,
|
||
receiver,
|
||
sdp,
|
||
channel_id: channelId
|
||
});
|
||
});
|
||
const send_sdp_answer = spacetimedb.reducer({
|
||
receiver: t.identity(),
|
||
sdp: t.string(),
|
||
channelId: t.u64()
|
||
}, (ctx, { receiver, sdp, channelId }) => {
|
||
ctx.db.sdp_answer.insert({
|
||
sender: ctx.sender,
|
||
receiver,
|
||
sdp,
|
||
channel_id: channelId
|
||
});
|
||
});
|
||
const send_ice_candidate = spacetimedb.reducer({
|
||
receiver: t.identity(),
|
||
candidate: t.string(),
|
||
channelId: t.u64()
|
||
}, (ctx, { receiver, candidate, channelId }) => {
|
||
ctx.db.ice_candidate.insert({
|
||
sender: ctx.sender,
|
||
receiver,
|
||
candidate,
|
||
channel_id: channelId
|
||
});
|
||
});
|
||
function clearSignalingForUser(ctx, identity) {
|
||
const userOffers = ctx.db.sdp_offer.iter().filter((offer) => offer.sender.isEqual(identity) || offer.receiver.isEqual(identity));
|
||
for (const offer of userOffers) ctx.db.sdp_offer.delete(offer.id);
|
||
const userAnswers = ctx.db.sdp_answer.iter().filter((answer) => answer.sender.isEqual(identity) || answer.receiver.isEqual(identity));
|
||
for (const answer of userAnswers) ctx.db.sdp_answer.delete(answer.id);
|
||
const userCandidates = ctx.db.ice_candidate.iter().filter((candidate) => candidate.sender.isEqual(identity) || candidate.receiver.isEqual(identity));
|
||
for (const candidate of userCandidates) ctx.db.ice_candidate.delete(candidate.id);
|
||
}
|
||
const create_thread = spacetimedb.reducer({
|
||
name: t.string(),
|
||
channelId: t.u64(),
|
||
parentMessageId: t.u64()
|
||
}, (ctx, { name, channelId, parentMessageId }) => {
|
||
validateName(name);
|
||
const user = ctx.db.user.identity.find(ctx.sender);
|
||
if (!user || !user.username && !user.subject) throw new SenderError("You must be logged in to create a thread");
|
||
if (!ctx.db.message.id.find(parentMessageId)) throw new SenderError("Parent message not found");
|
||
ctx.db.thread.insert({
|
||
id: 0n,
|
||
channel_id: channelId,
|
||
parent_message_id: parentMessageId,
|
||
name
|
||
});
|
||
});
|
||
const send_message = spacetimedb.reducer({
|
||
text: t.string(),
|
||
channelId: t.u64(),
|
||
threadId: t.u64().optional()
|
||
}, (ctx, { text, channelId, threadId }) => {
|
||
if (!text || text.trim().length === 0) throw new SenderError("Messages must not be empty");
|
||
const user = ctx.db.user.identity.find(ctx.sender);
|
||
if (!user || !user.username && !user.subject) throw new SenderError("You must be logged in to send messages");
|
||
ctx.db.message.insert({
|
||
id: 0n,
|
||
sender: ctx.sender,
|
||
text,
|
||
sent: ctx.timestamp,
|
||
channel_id: channelId,
|
||
thread_id: threadId
|
||
});
|
||
});
|
||
const init = spacetimedb.init((ctx) => {
|
||
let hasServers = false;
|
||
for (const _ of ctx.db.server.iter()) {
|
||
hasServers = true;
|
||
break;
|
||
}
|
||
if (!hasServers) {
|
||
const s = ctx.db.server.insert({
|
||
id: 0n,
|
||
name: "Spacetime Community",
|
||
owner: void 0
|
||
});
|
||
ctx.db.channel.insert({
|
||
id: 0n,
|
||
server_id: s.id,
|
||
name: "general",
|
||
kind: { tag: "text" }
|
||
});
|
||
ctx.db.channel.insert({
|
||
id: 0n,
|
||
server_id: s.id,
|
||
name: "Voice General",
|
||
kind: { tag: "voice" }
|
||
});
|
||
}
|
||
});
|
||
const onConnect = spacetimedb.clientConnected((ctx) => {
|
||
const user = ctx.db.user.identity.find(ctx.sender);
|
||
if (ctx.senderAuth.hasJWT && ctx.senderAuth.jwt) {
|
||
const jwt = ctx.senderAuth.jwt;
|
||
const issuer = jwt.issuer;
|
||
const subject = jwt.subject;
|
||
const payload = jwt.fullPayload;
|
||
const name = payload.name || payload.nickname || payload.preferred_username || payload.email;
|
||
if (user) ctx.db.user.identity.update({
|
||
...user,
|
||
online: true,
|
||
name: user.name || name,
|
||
issuer,
|
||
subject
|
||
});
|
||
else ctx.db.user.insert({
|
||
name,
|
||
identity: ctx.sender,
|
||
online: true,
|
||
issuer,
|
||
subject,
|
||
username: void 0,
|
||
password: void 0
|
||
});
|
||
} else if (user) ctx.db.user.identity.update({
|
||
...user,
|
||
online: true
|
||
});
|
||
});
|
||
const onDisconnect = spacetimedb.clientDisconnected((ctx) => {
|
||
const user = ctx.db.user.identity.find(ctx.sender);
|
||
if (user) ctx.db.user.identity.update({
|
||
...user,
|
||
online: false
|
||
});
|
||
ctx.db.voice_state.identity.delete(ctx.sender);
|
||
clearSignalingForUser(ctx, ctx.sender);
|
||
});
|
||
|
||
//#endregion
|
||
export { create_channel, create_server, create_thread, spacetimedb as default, init, join_voice, leave_voice, login, onConnect, onDisconnect, register, send_ice_candidate, send_message, send_sdp_answer, send_sdp_offer, set_name };
|
||
//# debugId=c9a38ab5-d5c5-4af9-81c8-7086063e3faf
|
||
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"bundle.js","names":["__create","__defProp","__getOwnPropDesc","__getOwnPropNames","__getProtoOf","__hasOwnProp","__commonJS","__copyProps","__toESM","#ensure","#moduleDef","#registerCompoundTypeRecursively","#compoundTypes","#from","#to","#uuidCounter","#senderAuth","#identity","#random","#schema","#reducerArgsDeserializers","#dbView","#dbView_","#reducerCtx","#reducerCtx_","#finalizationRegistry","#id","#detach","#body","#inner","#ctx"],"sources":["node_modules/.pnpm/headers-polyfill@4.0.3/node_modules/headers-polyfill/lib/index.mjs","node_modules/.pnpm/spacetimedb@2.1.0/node_modules/spacetimedb/dist/server/index.mjs","src/index.ts"],"sourcesContent":["var __create = Object.create;\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __getProtoOf = Object.getPrototypeOf;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __commonJS = (cb, mod) => function __require() {\n  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(\n  // If the importer is in node compatibility mode or this is not an ESM\n  // file that has been converted to a CommonJS file using a Babel-\n  // compatible transform (i.e. \"__esModule\" has not been set), then set\n  // \"default\" to the CommonJS \"module.exports\" for node compatibility.\n  isNodeMode || !mod || !mod.__esModule ? __defProp(target, \"default\", { value: mod, enumerable: true }) : target,\n  mod\n));\n\n// node_modules/set-cookie-parser/lib/set-cookie.js\nvar require_set_cookie = __commonJS({\n  \"node_modules/set-cookie-parser/lib/set-cookie.js\"(exports, module) {\n    \"use strict\";\n    var defaultParseOptions = {\n      decodeValues: true,\n      map: false,\n      silent: false\n    };\n    function isNonEmptyString(str) {\n      return typeof str === \"string\" && !!str.trim();\n    }\n    function parseString(setCookieValue, options) {\n      var parts = setCookieValue.split(\";\").filter(isNonEmptyString);\n      var nameValuePairStr = parts.shift();\n      var parsed = parseNameValuePair(nameValuePairStr);\n      var name = parsed.name;\n      var value = parsed.value;\n      options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;\n      try {\n        value = options.decodeValues ? decodeURIComponent(value) : value;\n      } catch (e) {\n        console.error(\n          \"set-cookie-parser encountered an error while decoding a cookie with value '\" + value + \"'. Set options.decodeValues to false to disable this feature.\",\n          e\n        );\n      }\n      var cookie = {\n        name,\n        value\n      };\n      parts.forEach(function(part) {\n        var sides = part.split(\"=\");\n        var key = sides.shift().trimLeft().toLowerCase();\n        var value2 = sides.join(\"=\");\n        if (key === \"expires\") {\n          cookie.expires = new Date(value2);\n        } else if (key === \"max-age\") {\n          cookie.maxAge = parseInt(value2, 10);\n        } else if (key === \"secure\") {\n          cookie.secure = true;\n        } else if (key === \"httponly\") {\n          cookie.httpOnly = true;\n        } else if (key === \"samesite\") {\n          cookie.sameSite = value2;\n        } else {\n          cookie[key] = value2;\n        }\n      });\n      return cookie;\n    }\n    function parseNameValuePair(nameValuePairStr) {\n      var name = \"\";\n      var value = \"\";\n      var nameValueArr = nameValuePairStr.split(\"=\");\n      if (nameValueArr.length > 1) {\n        name = nameValueArr.shift();\n        value = nameValueArr.join(\"=\");\n      } else {\n        value = nameValuePairStr;\n      }\n      return { name, value };\n    }\n    function parse(input, options) {\n      options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;\n      if (!input) {\n        if (!options.map) {\n          return [];\n        } else {\n          return {};\n        }\n      }\n      if (input.headers) {\n        if (typeof input.headers.getSetCookie === \"function\") {\n          input = input.headers.getSetCookie();\n        } else if (input.headers[\"set-cookie\"]) {\n          input = input.headers[\"set-cookie\"];\n        } else {\n          var sch = input.headers[Object.keys(input.headers).find(function(key) {\n            return key.toLowerCase() === \"set-cookie\";\n          })];\n          if (!sch && input.headers.cookie && !options.silent) {\n            console.warn(\n              \"Warning: set-cookie-parser appears to have been called on a request object. It is designed to parse Set-Cookie headers from responses, not Cookie headers from requests. Set the option {silent: true} to suppress this warning.\"\n            );\n          }\n          input = sch;\n        }\n      }\n      if (!Array.isArray(input)) {\n        input = [input];\n      }\n      options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;\n      if (!options.map) {\n        return input.filter(isNonEmptyString).map(function(str) {\n          return parseString(str, options);\n        });\n      } else {\n        var cookies = {};\n        return input.filter(isNonEmptyString).reduce(function(cookies2, str) {\n          var cookie = parseString(str, options);\n          cookies2[cookie.name] = cookie;\n          return cookies2;\n        }, cookies);\n      }\n    }\n    function splitCookiesString2(cookiesString) {\n      if (Array.isArray(cookiesString)) {\n        return cookiesString;\n      }\n      if (typeof cookiesString !== \"string\") {\n        return [];\n      }\n      var cookiesStrings = [];\n      var pos = 0;\n      var start;\n      var ch;\n      var lastComma;\n      var nextStart;\n      var cookiesSeparatorFound;\n      function skipWhitespace() {\n        while (pos < cookiesString.length && /\\s/.test(cookiesString.charAt(pos))) {\n          pos += 1;\n        }\n        return pos < cookiesString.length;\n      }\n      function notSpecialChar() {\n        ch = cookiesString.charAt(pos);\n        return ch !== \"=\" && ch !== \";\" && ch !== \",\";\n      }\n      while (pos < cookiesString.length) {\n        start = pos;\n        cookiesSeparatorFound = false;\n        while (skipWhitespace()) {\n          ch = cookiesString.charAt(pos);\n          if (ch === \",\") {\n            lastComma = pos;\n            pos += 1;\n            skipWhitespace();\n            nextStart = pos;\n            while (pos < cookiesString.length && notSpecialChar()) {\n              pos += 1;\n            }\n            if (pos < cookiesString.length && cookiesString.charAt(pos) === \"=\") {\n              cookiesSeparatorFound = true;\n              pos = nextStart;\n              cookiesStrings.push(cookiesString.substring(start, lastComma));\n              start = pos;\n            } else {\n              pos = lastComma + 1;\n            }\n          } else {\n            pos += 1;\n          }\n        }\n        if (!cookiesSeparatorFound || pos >= cookiesString.length) {\n          cookiesStrings.push(cookiesString.substring(start, cookiesString.length));\n        }\n      }\n      return cookiesStrings;\n    }\n    module.exports = parse;\n    module.exports.parse = parse;\n    module.exports.parseString = parseString;\n    module.exports.splitCookiesString = splitCookiesString2;\n  }\n});\n\n// src/Headers.ts\nvar import_set_cookie_parser = __toESM(require_set_cookie());\n\n// src/utils/normalizeHeaderName.ts\nvar HEADERS_INVALID_CHARACTERS = /[^a-z0-9\\-#$%&'*+.^_`|~]/i;\nfunction normalizeHeaderName(name) {\n  if (HEADERS_INVALID_CHARACTERS.test(name) || name.trim() === \"\") {\n    throw new TypeError(\"Invalid character in header field name\");\n  }\n  return name.trim().toLowerCase();\n}\n\n// src/utils/normalizeHeaderValue.ts\nvar charCodesToRemove = [\n  String.fromCharCode(10),\n  String.fromCharCode(13),\n  String.fromCharCode(9),\n  String.fromCharCode(32)\n];\nvar HEADER_VALUE_REMOVE_REGEXP = new RegExp(\n  `(^[${charCodesToRemove.join(\"\")}]|$[${charCodesToRemove.join(\"\")}])`,\n  \"g\"\n);\nfunction normalizeHeaderValue(value) {\n  const nextValue = value.replace(HEADER_VALUE_REMOVE_REGEXP, \"\");\n  return nextValue;\n}\n\n// src/utils/isValidHeaderName.ts\nfunction isValidHeaderName(value) {\n  if (typeof value !== \"string\") {\n    return false;\n  }\n  if (value.length === 0) {\n    return false;\n  }\n  for (let i = 0; i < value.length; i++) {\n    const character = value.charCodeAt(i);\n    if (character > 127 || !isToken(character)) {\n      return false;\n    }\n  }\n  return true;\n}\nfunction isToken(value) {\n  return ![\n    127,\n    32,\n    \"(\",\n    \")\",\n    \"<\",\n    \">\",\n    \"@\",\n    \",\",\n    \";\",\n    \":\",\n    \"\\\\\",\n    '\"',\n    \"/\",\n    \"[\",\n    \"]\",\n    \"?\",\n    \"=\",\n    \"{\",\n    \"}\"\n  ].includes(value);\n}\n\n// src/utils/isValidHeaderValue.ts\nfunction isValidHeaderValue(value) {\n  if (typeof value !== \"string\") {\n    return false;\n  }\n  if (value.trim() !== value) {\n    return false;\n  }\n  for (let i = 0; i < value.length; i++) {\n    const character = value.charCodeAt(i);\n    if (\n      // NUL.\n      character === 0 || // HTTP newline bytes.\n      character === 10 || character === 13\n    ) {\n      return false;\n    }\n  }\n  return true;\n}\n\n// src/Headers.ts\nvar NORMALIZED_HEADERS = Symbol(\"normalizedHeaders\");\nvar RAW_HEADER_NAMES = Symbol(\"rawHeaderNames\");\nvar HEADER_VALUE_DELIMITER = \", \";\nvar _a, _b, _c;\nvar Headers = class _Headers {\n  constructor(init) {\n    // Normalized header {\"name\":\"a, b\"} storage.\n    this[_a] = {};\n    // Keeps the mapping between the raw header name\n    // and the normalized header name to ease the lookup.\n    this[_b] = /* @__PURE__ */ new Map();\n    this[_c] = \"Headers\";\n    if ([\"Headers\", \"HeadersPolyfill\"].includes(init?.constructor.name) || init instanceof _Headers || typeof globalThis.Headers !== \"undefined\" && init instanceof globalThis.Headers) {\n      const initialHeaders = init;\n      initialHeaders.forEach((value, name) => {\n        this.append(name, value);\n      }, this);\n    } else if (Array.isArray(init)) {\n      init.forEach(([name, value]) => {\n        this.append(\n          name,\n          Array.isArray(value) ? value.join(HEADER_VALUE_DELIMITER) : value\n        );\n      });\n    } else if (init) {\n      Object.getOwnPropertyNames(init).forEach((name) => {\n        const value = init[name];\n        this.append(\n          name,\n          Array.isArray(value) ? value.join(HEADER_VALUE_DELIMITER) : value\n        );\n      });\n    }\n  }\n  [(_a = NORMALIZED_HEADERS, _b = RAW_HEADER_NAMES, _c = Symbol.toStringTag, Symbol.iterator)]() {\n    return this.entries();\n  }\n  *keys() {\n    for (const [name] of this.entries()) {\n      yield name;\n    }\n  }\n  *values() {\n    for (const [, value] of this.entries()) {\n      yield value;\n    }\n  }\n  *entries() {\n    let sortedKeys = Object.keys(this[NORMALIZED_HEADERS]).sort(\n      (a, b) => a.localeCompare(b)\n    );\n    for (const name of sortedKeys) {\n      if (name === \"set-cookie\") {\n        for (const value of this.getSetCookie()) {\n          yield [name, value];\n        }\n      } else {\n        yield [name, this.get(name)];\n      }\n    }\n  }\n  /**\n   * Returns a boolean stating whether a `Headers` object contains a certain header.\n   */\n  has(name) {\n    if (!isValidHeaderName(name)) {\n      throw new TypeError(`Invalid header name \"${name}\"`);\n    }\n    return this[NORMALIZED_HEADERS].hasOwnProperty(normalizeHeaderName(name));\n  }\n  /**\n   * Returns a `ByteString` sequence of all the values of a header with a given name.\n   */\n  get(name) {\n    if (!isValidHeaderName(name)) {\n      throw TypeError(`Invalid header name \"${name}\"`);\n    }\n    return this[NORMALIZED_HEADERS][normalizeHeaderName(name)] ?? null;\n  }\n  /**\n   * Sets a new value for an existing header inside a `Headers` object, or adds the header if it does not already exist.\n   */\n  set(name, value) {\n    if (!isValidHeaderName(name) || !isValidHeaderValue(value)) {\n      return;\n    }\n    const normalizedName = normalizeHeaderName(name);\n    const normalizedValue = normalizeHeaderValue(value);\n    this[NORMALIZED_HEADERS][normalizedName] = normalizeHeaderValue(normalizedValue);\n    this[RAW_HEADER_NAMES].set(normalizedName, name);\n  }\n  /**\n   * Appends a new value onto an existing header inside a `Headers` object, or adds the header if it does not already exist.\n   */\n  append(name, value) {\n    if (!isValidHeaderName(name) || !isValidHeaderValue(value)) {\n      return;\n    }\n    const normalizedName = normalizeHeaderName(name);\n    const normalizedValue = normalizeHeaderValue(value);\n    let resolvedValue = this.has(normalizedName) ? `${this.get(normalizedName)}, ${normalizedValue}` : normalizedValue;\n    this.set(name, resolvedValue);\n  }\n  /**\n   * Deletes a header from the `Headers` object.\n   */\n  delete(name) {\n    if (!isValidHeaderName(name)) {\n      return;\n    }\n    if (!this.has(name)) {\n      return;\n    }\n    const normalizedName = normalizeHeaderName(name);\n    delete this[NORMALIZED_HEADERS][normalizedName];\n    this[RAW_HEADER_NAMES].delete(normalizedName);\n  }\n  /**\n   * Traverses the `Headers` object,\n   * calling the given callback for each header.\n   */\n  forEach(callback, thisArg) {\n    for (const [name, value] of this.entries()) {\n      callback.call(thisArg, value, name, this);\n    }\n  }\n  /**\n   * Returns an array containing the values\n   * of all Set-Cookie headers associated\n   * with a response\n   */\n  getSetCookie() {\n    const setCookieHeader = this.get(\"set-cookie\");\n    if (setCookieHeader === null) {\n      return [];\n    }\n    if (setCookieHeader === \"\") {\n      return [\"\"];\n    }\n    return (0, import_set_cookie_parser.splitCookiesString)(setCookieHeader);\n  }\n};\n\n// src/getRawHeaders.ts\nfunction getRawHeaders(headers) {\n  const rawHeaders = {};\n  for (const [name, value] of headers.entries()) {\n    rawHeaders[headers[RAW_HEADER_NAMES].get(name)] = value;\n  }\n  return rawHeaders;\n}\n\n// src/transformers/headersToList.ts\nfunction headersToList(headers) {\n  const headersList = [];\n  headers.forEach((value, name) => {\n    const resolvedValue = value.includes(\",\") ? value.split(\",\").map((value2) => value2.trim()) : value;\n    headersList.push([name, resolvedValue]);\n  });\n  return headersList;\n}\n\n// src/transformers/headersToString.ts\nfunction headersToString(headers) {\n  const list = headersToList(headers);\n  const lines = list.map(([name, value]) => {\n    const values = [].concat(value);\n    return `${name}: ${values.join(\", \")}`;\n  });\n  return lines.join(\"\\r\\n\");\n}\n\n// src/transformers/headersToObject.ts\nvar singleValueHeaders = [\"user-agent\"];\nfunction headersToObject(headers) {\n  const headersObject = {};\n  headers.forEach((value, name) => {\n    const isMultiValue = !singleValueHeaders.includes(name.toLowerCase()) && value.includes(\",\");\n    headersObject[name] = isMultiValue ? value.split(\",\").map((s) => s.trim()) : value;\n  });\n  return headersObject;\n}\n\n// src/transformers/stringToHeaders.ts\nfunction stringToHeaders(str) {\n  const lines = str.trim().split(/[\\r\\n]+/);\n  return lines.reduce((headers, line) => {\n    if (line.trim() === \"\") {\n      return headers;\n    }\n    const parts = line.split(\": \");\n    const name = parts.shift();\n    const value = parts.join(\": \");\n    headers.append(name, value);\n    return headers;\n  }, new Headers());\n}\n\n// src/transformers/listToHeaders.ts\nfunction listToHeaders(list) {\n  const headers = new Headers();\n  list.forEach(([name, value]) => {\n    const values = [].concat(value);\n    values.forEach((value2) => {\n      headers.append(name, value2);\n    });\n  });\n  return headers;\n}\n\n// src/transformers/reduceHeadersObject.ts\nfunction reduceHeadersObject(headers, reducer, initialState) {\n  return Object.keys(headers).reduce((nextHeaders, name) => {\n    return reducer(nextHeaders, name, headers[name]);\n  }, initialState);\n}\n\n// src/transformers/objectToHeaders.ts\nfunction objectToHeaders(headersObject) {\n  return reduceHeadersObject(\n    headersObject,\n    (headers, name, value) => {\n      const values = [].concat(value).filter(Boolean);\n      values.forEach((value2) => {\n        headers.append(name, value2);\n      });\n      return headers;\n    },\n    new Headers()\n  );\n}\n\n// src/transformers/flattenHeadersList.ts\nfunction flattenHeadersList(list) {\n  return list.map(([name, values]) => {\n    return [name, [].concat(values).join(\", \")];\n  });\n}\n\n// src/transformers/flattenHeadersObject.ts\nfunction flattenHeadersObject(headersObject) {\n  return reduceHeadersObject(\n    headersObject,\n    (headers, name, value) => {\n      headers[name] = [].concat(value).join(\", \");\n      return headers;\n    },\n    {}\n  );\n}\nexport {\n  Headers,\n  flattenHeadersList,\n  flattenHeadersObject,\n  getRawHeaders,\n  headersToList,\n  headersToObject,\n  headersToString,\n  listToHeaders,\n  objectToHeaders,\n  reduceHeadersObject,\n  stringToHeaders\n};\n//# sourceMappingURL=index.mjs.map","import * as _syscalls2_0 from 'spacetime:sys@2.0';\nimport { moduleHooks } from 'spacetime:sys@2.0';\nimport { headersToList, Headers } from 'headers-polyfill';\n\ntypeof globalThis!==\"undefined\"&&((globalThis.global=globalThis.global||globalThis),(globalThis.window=globalThis.window||globalThis));\nvar __create = Object.create;\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __getProtoOf = Object.getPrototypeOf;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __esm = (fn, res) => function __init() {\n  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;\n};\nvar __commonJS = (cb, mod) => function __require() {\n  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;\n};\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(\n  // If the importer is in node compatibility mode or this is not an ESM\n  // file that has been converted to a CommonJS file using a Babel-\n  // compatible transform (i.e. \"__esModule\" has not been set), then set\n  // \"default\" to the CommonJS \"module.exports\" for node compatibility.\n  __defProp(target, \"default\", { value: mod, enumerable: true }) ,\n  mod\n));\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\n\n// ../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js\nvar require_base64_js = __commonJS({\n  \"../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js\"(exports) {\n    exports.byteLength = byteLength;\n    exports.toByteArray = toByteArray;\n    exports.fromByteArray = fromByteArray2;\n    var lookup = [];\n    var revLookup = [];\n    var Arr = typeof Uint8Array !== \"undefined\" ? Uint8Array : Array;\n    var code = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\n    for (i = 0, len = code.length; i < len; ++i) {\n      lookup[i] = code[i];\n      revLookup[code.charCodeAt(i)] = i;\n    }\n    var i;\n    var len;\n    revLookup[\"-\".charCodeAt(0)] = 62;\n    revLookup[\"_\".charCodeAt(0)] = 63;\n    function getLens(b64) {\n      var len2 = b64.length;\n      if (len2 % 4 > 0) {\n        throw new Error(\"Invalid string. Length must be a multiple of 4\");\n      }\n      var validLen = b64.indexOf(\"=\");\n      if (validLen === -1) validLen = len2;\n      var placeHoldersLen = validLen === len2 ? 0 : 4 - validLen % 4;\n      return [validLen, placeHoldersLen];\n    }\n    function byteLength(b64) {\n      var lens = getLens(b64);\n      var validLen = lens[0];\n      var placeHoldersLen = lens[1];\n      return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;\n    }\n    function _byteLength(b64, validLen, placeHoldersLen) {\n      return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;\n    }\n    function toByteArray(b64) {\n      var tmp;\n      var lens = getLens(b64);\n      var validLen = lens[0];\n      var placeHoldersLen = lens[1];\n      var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));\n      var curByte = 0;\n      var len2 = placeHoldersLen > 0 ? validLen - 4 : validLen;\n      var i2;\n      for (i2 = 0; i2 < len2; i2 += 4) {\n        tmp = revLookup[b64.charCodeAt(i2)] << 18 | revLookup[b64.charCodeAt(i2 + 1)] << 12 | revLookup[b64.charCodeAt(i2 + 2)] << 6 | revLookup[b64.charCodeAt(i2 + 3)];\n        arr[curByte++] = tmp >> 16 & 255;\n        arr[curByte++] = tmp >> 8 & 255;\n        arr[curByte++] = tmp & 255;\n      }\n      if (placeHoldersLen === 2) {\n        tmp = revLookup[b64.charCodeAt(i2)] << 2 | revLookup[b64.charCodeAt(i2 + 1)] >> 4;\n        arr[curByte++] = tmp & 255;\n      }\n      if (placeHoldersLen === 1) {\n        tmp = revLookup[b64.charCodeAt(i2)] << 10 | revLookup[b64.charCodeAt(i2 + 1)] << 4 | revLookup[b64.charCodeAt(i2 + 2)] >> 2;\n        arr[curByte++] = tmp >> 8 & 255;\n        arr[curByte++] = tmp & 255;\n      }\n      return arr;\n    }\n    function tripletToBase64(num) {\n      return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];\n    }\n    function encodeChunk(uint8, start, end) {\n      var tmp;\n      var output = [];\n      for (var i2 = start; i2 < end; i2 += 3) {\n        tmp = (uint8[i2] << 16 & 16711680) + (uint8[i2 + 1] << 8 & 65280) + (uint8[i2 + 2] & 255);\n        output.push(tripletToBase64(tmp));\n      }\n      return output.join(\"\");\n    }\n    function fromByteArray2(uint8) {\n      var tmp;\n      var len2 = uint8.length;\n      var extraBytes = len2 % 3;\n      var parts = [];\n      var maxChunkLength = 16383;\n      for (var i2 = 0, len22 = len2 - extraBytes; i2 < len22; i2 += maxChunkLength) {\n        parts.push(encodeChunk(uint8, i2, i2 + maxChunkLength > len22 ? len22 : i2 + maxChunkLength));\n      }\n      if (extraBytes === 1) {\n        tmp = uint8[len2 - 1];\n        parts.push(\n          lookup[tmp >> 2] + lookup[tmp << 4 & 63] + \"==\"\n        );\n      } else if (extraBytes === 2) {\n        tmp = (uint8[len2 - 2] << 8) + uint8[len2 - 1];\n        parts.push(\n          lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + \"=\"\n        );\n      }\n      return parts.join(\"\");\n    }\n  }\n});\n\n// ../../node_modules/.pnpm/statuses@2.0.2/node_modules/statuses/codes.json\nvar require_codes = __commonJS({\n  \"../../node_modules/.pnpm/statuses@2.0.2/node_modules/statuses/codes.json\"(exports, module) {\n    module.exports = {\n      \"100\": \"Continue\",\n      \"101\": \"Switching Protocols\",\n      \"102\": \"Processing\",\n      \"103\": \"Early Hints\",\n      \"200\": \"OK\",\n      \"201\": \"Created\",\n      \"202\": \"Accepted\",\n      \"203\": \"Non-Authoritative Information\",\n      \"204\": \"No Content\",\n      \"205\": \"Reset Content\",\n      \"206\": \"Partial Content\",\n      \"207\": \"Multi-Status\",\n      \"208\": \"Already Reported\",\n      \"226\": \"IM Used\",\n      \"300\": \"Multiple Choices\",\n      \"301\": \"Moved Permanently\",\n      \"302\": \"Found\",\n      \"303\": \"See Other\",\n      \"304\": \"Not Modified\",\n      \"305\": \"Use Proxy\",\n      \"307\": \"Temporary Redirect\",\n      \"308\": \"Permanent Redirect\",\n      \"400\": \"Bad Request\",\n      \"401\": \"Unauthorized\",\n      \"402\": \"Payment Required\",\n      \"403\": \"Forbidden\",\n      \"404\": \"Not Found\",\n      \"405\": \"Method Not Allowed\",\n      \"406\": \"Not Acceptable\",\n      \"407\": \"Proxy Authentication Required\",\n      \"408\": \"Request Timeout\",\n      \"409\": \"Conflict\",\n      \"410\": \"Gone\",\n      \"411\": \"Length Required\",\n      \"412\": \"Precondition Failed\",\n      \"413\": \"Payload Too Large\",\n      \"414\": \"URI Too Long\",\n      \"415\": \"Unsupported Media Type\",\n      \"416\": \"Range Not Satisfiable\",\n      \"417\": \"Expectation Failed\",\n      \"418\": \"I'm a Teapot\",\n      \"421\": \"Misdirected Request\",\n      \"422\": \"Unprocessable Entity\",\n      \"423\": \"Locked\",\n      \"424\": \"Failed Dependency\",\n      \"425\": \"Too Early\",\n      \"426\": \"Upgrade Required\",\n      \"428\": \"Precondition Required\",\n      \"429\": \"Too Many Requests\",\n      \"431\": \"Request Header Fields Too Large\",\n      \"451\": \"Unavailable For Legal Reasons\",\n      \"500\": \"Internal Server Error\",\n      \"501\": \"Not Implemented\",\n      \"502\": \"Bad Gateway\",\n      \"503\": \"Service Unavailable\",\n      \"504\": \"Gateway Timeout\",\n      \"505\": \"HTTP Version Not Supported\",\n      \"506\": \"Variant Also Negotiates\",\n      \"507\": \"Insufficient Storage\",\n      \"508\": \"Loop Detected\",\n      \"509\": \"Bandwidth Limit Exceeded\",\n      \"510\": \"Not Extended\",\n      \"511\": \"Network Authentication Required\"\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/statuses@2.0.2/node_modules/statuses/index.js\nvar require_statuses = __commonJS({\n  \"../../node_modules/.pnpm/statuses@2.0.2/node_modules/statuses/index.js\"(exports, module) {\n    var codes = require_codes();\n    module.exports = status2;\n    status2.message = codes;\n    status2.code = createMessageToStatusCodeMap(codes);\n    status2.codes = createStatusCodeList(codes);\n    status2.redirect = {\n      300: true,\n      301: true,\n      302: true,\n      303: true,\n      305: true,\n      307: true,\n      308: true\n    };\n    status2.empty = {\n      204: true,\n      205: true,\n      304: true\n    };\n    status2.retry = {\n      502: true,\n      503: true,\n      504: true\n    };\n    function createMessageToStatusCodeMap(codes2) {\n      var map = {};\n      Object.keys(codes2).forEach(function forEachCode(code) {\n        var message = codes2[code];\n        var status3 = Number(code);\n        map[message.toLowerCase()] = status3;\n      });\n      return map;\n    }\n    function createStatusCodeList(codes2) {\n      return Object.keys(codes2).map(function mapCode(code) {\n        return Number(code);\n      });\n    }\n    function getStatusCode(message) {\n      var msg = message.toLowerCase();\n      if (!Object.prototype.hasOwnProperty.call(status2.code, msg)) {\n        throw new Error('invalid status message: \"' + message + '\"');\n      }\n      return status2.code[msg];\n    }\n    function getStatusMessage(code) {\n      if (!Object.prototype.hasOwnProperty.call(status2.message, code)) {\n        throw new Error(\"invalid status code: \" + code);\n      }\n      return status2.message[code];\n    }\n    function status2(code) {\n      if (typeof code === \"number\") {\n        return getStatusMessage(code);\n      }\n      if (typeof code !== \"string\") {\n        throw new TypeError(\"code must be a number or string\");\n      }\n      var n = parseInt(code, 10);\n      if (!isNaN(n)) {\n        return getStatusMessage(n);\n      }\n      return getStatusCode(code);\n    }\n  }\n});\n\n// src/util-stub.ts\nvar util_stub_exports = {};\n__export(util_stub_exports, {\n  inspect: () => inspect\n});\nvar inspect;\nvar init_util_stub = __esm({\n  \"src/util-stub.ts\"() {\n    inspect = {};\n  }\n});\n\n// ../../node_modules/.pnpm/object-inspect@1.13.4/node_modules/object-inspect/util.inspect.js\nvar require_util_inspect = __commonJS({\n  \"../../node_modules/.pnpm/object-inspect@1.13.4/node_modules/object-inspect/util.inspect.js\"(exports, module) {\n    module.exports = (init_util_stub(), __toCommonJS(util_stub_exports)).inspect;\n  }\n});\n\n// ../../node_modules/.pnpm/object-inspect@1.13.4/node_modules/object-inspect/index.js\nvar require_object_inspect = __commonJS({\n  \"../../node_modules/.pnpm/object-inspect@1.13.4/node_modules/object-inspect/index.js\"(exports, module) {\n    var hasMap = typeof Map === \"function\" && Map.prototype;\n    var mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ? Object.getOwnPropertyDescriptor(Map.prototype, \"size\") : null;\n    var mapSize = hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get === \"function\" ? mapSizeDescriptor.get : null;\n    var mapForEach = hasMap && Map.prototype.forEach;\n    var hasSet = typeof Set === \"function\" && Set.prototype;\n    var setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ? Object.getOwnPropertyDescriptor(Set.prototype, \"size\") : null;\n    var setSize = hasSet && setSizeDescriptor && typeof setSizeDescriptor.get === \"function\" ? setSizeDescriptor.get : null;\n    var setForEach = hasSet && Set.prototype.forEach;\n    var hasWeakMap = typeof WeakMap === \"function\" && WeakMap.prototype;\n    var weakMapHas = hasWeakMap ? WeakMap.prototype.has : null;\n    var hasWeakSet = typeof WeakSet === \"function\" && WeakSet.prototype;\n    var weakSetHas = hasWeakSet ? WeakSet.prototype.has : null;\n    var hasWeakRef = typeof WeakRef === \"function\" && WeakRef.prototype;\n    var weakRefDeref = hasWeakRef ? WeakRef.prototype.deref : null;\n    var booleanValueOf = Boolean.prototype.valueOf;\n    var objectToString = Object.prototype.toString;\n    var functionToString = Function.prototype.toString;\n    var $match = String.prototype.match;\n    var $slice = String.prototype.slice;\n    var $replace = String.prototype.replace;\n    var $toUpperCase = String.prototype.toUpperCase;\n    var $toLowerCase = String.prototype.toLowerCase;\n    var $test = RegExp.prototype.test;\n    var $concat = Array.prototype.concat;\n    var $join = Array.prototype.join;\n    var $arrSlice = Array.prototype.slice;\n    var $floor = Math.floor;\n    var bigIntValueOf = typeof BigInt === \"function\" ? BigInt.prototype.valueOf : null;\n    var gOPS = Object.getOwnPropertySymbols;\n    var symToString = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? Symbol.prototype.toString : null;\n    var hasShammedSymbols = typeof Symbol === \"function\" && typeof Symbol.iterator === \"object\";\n    var toStringTag = typeof Symbol === \"function\" && Symbol.toStringTag && (typeof Symbol.toStringTag === hasShammedSymbols ? \"object\" : \"symbol\") ? Symbol.toStringTag : null;\n    var isEnumerable = Object.prototype.propertyIsEnumerable;\n    var gPO = (typeof Reflect === \"function\" ? Reflect.getPrototypeOf : Object.getPrototypeOf) || ([].__proto__ === Array.prototype ? function(O) {\n      return O.__proto__;\n    } : null);\n    function addNumericSeparator(num, str) {\n      if (num === Infinity || num === -Infinity || num !== num || num && num > -1e3 && num < 1e3 || $test.call(/e/, str)) {\n        return str;\n      }\n      var sepRegex = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g;\n      if (typeof num === \"number\") {\n        var int = num < 0 ? -$floor(-num) : $floor(num);\n        if (int !== num) {\n          var intStr = String(int);\n          var dec = $slice.call(str, intStr.length + 1);\n          return $replace.call(intStr, sepRegex, \"$&_\") + \".\" + $replace.call($replace.call(dec, /([0-9]{3})/g, \"$&_\"), /_$/, \"\");\n        }\n      }\n      return $replace.call(str, sepRegex, \"$&_\");\n    }\n    var utilInspect = require_util_inspect();\n    var inspectCustom = utilInspect.custom;\n    var inspectSymbol = isSymbol(inspectCustom) ? inspectCustom : null;\n    var quotes = {\n      __proto__: null,\n      \"double\": '\"',\n      single: \"'\"\n    };\n    var quoteREs = {\n      __proto__: null,\n      \"double\": /([\"\\\\])/g,\n      single: /(['\\\\])/g\n    };\n    module.exports = function inspect_(obj, options, depth, seen) {\n      var opts = options || {};\n      if (has(opts, \"quoteStyle\") && !has(quotes, opts.quoteStyle)) {\n        throw new TypeError('option \"quoteStyle\" must be \"single\" or \"double\"');\n      }\n      if (has(opts, \"maxStringLength\") && (typeof opts.maxStringLength === \"number\" ? opts.maxStringLength < 0 && opts.maxStringLength !== Infinity : opts.maxStringLength !== null)) {\n        throw new TypeError('option \"maxStringLength\", if provided, must be a positive integer, Infinity, or `null`');\n      }\n      var customInspect = has(opts, \"customInspect\") ? opts.customInspect : true;\n      if (typeof customInspect !== \"boolean\" && customInspect !== \"symbol\") {\n        throw new TypeError(\"option \\\"customInspect\\\", if provided, must be `true`, `false`, or `'symbol'`\");\n      }\n      if (has(opts, \"indent\") && opts.indent !== null && opts.indent !== \"\t\" && !(parseInt(opts.indent, 10) === opts.indent && opts.indent > 0)) {\n        throw new TypeError('option \"indent\" must be \"\\\\t\", an integer > 0, or `null`');\n      }\n      if (has(opts, \"numericSeparator\") && typeof opts.numericSeparator !== \"boolean\") {\n        throw new TypeError('option \"numericSeparator\", if provided, must be `true` or `false`');\n      }\n      var numericSeparator = opts.numericSeparator;\n      if (typeof obj === \"undefined\") {\n        return \"undefined\";\n      }\n      if (obj === null) {\n        return \"null\";\n      }\n      if (typeof obj === \"boolean\") {\n        return obj ? \"true\" : \"false\";\n      }\n      if (typeof obj === \"string\") {\n        return inspectString(obj, opts);\n      }\n      if (typeof obj === \"number\") {\n        if (obj === 0) {\n          return Infinity / obj > 0 ? \"0\" : \"-0\";\n        }\n        var str = String(obj);\n        return numericSeparator ? addNumericSeparator(obj, str) : str;\n      }\n      if (typeof obj === \"bigint\") {\n        var bigIntStr = String(obj) + \"n\";\n        return numericSeparator ? addNumericSeparator(obj, bigIntStr) : bigIntStr;\n      }\n      var maxDepth = typeof opts.depth === \"undefined\" ? 5 : opts.depth;\n      if (typeof depth === \"undefined\") {\n        depth = 0;\n      }\n      if (depth >= maxDepth && maxDepth > 0 && typeof obj === \"object\") {\n        return isArray(obj) ? \"[Array]\" : \"[Object]\";\n      }\n      var indent = getIndent(opts, depth);\n      if (typeof seen === \"undefined\") {\n        seen = [];\n      } else if (indexOf(seen, obj) >= 0) {\n        return \"[Circular]\";\n      }\n      function inspect3(value, from, noIndent) {\n        if (from) {\n          seen = $arrSlice.call(seen);\n          seen.push(from);\n        }\n        if (noIndent) {\n          var newOpts = {\n            depth: opts.depth\n          };\n          if (has(opts, \"quoteStyle\")) {\n            newOpts.quoteStyle = opts.quoteStyle;\n          }\n          return inspect_(value, newOpts, depth + 1, seen);\n        }\n        return inspect_(value, opts, depth + 1, seen);\n      }\n      if (typeof obj === \"function\" && !isRegExp(obj)) {\n        var name = nameOf(obj);\n        var keys = arrObjKeys(obj, inspect3);\n        return \"[Function\" + (name ? \": \" + name : \" (anonymous)\") + \"]\" + (keys.length > 0 ? \" { \" + $join.call(keys, \", \") + \" }\" : \"\");\n      }\n      if (isSymbol(obj)) {\n        var symString = hasShammedSymbols ? $replace.call(String(obj), /^(Symbol\\(.*\\))_[^)]*$/, \"$1\") : symToString.call(obj);\n        return typeof obj === \"object\" && !hasShammedSymbols ? markBoxed(symString) : symString;\n      }\n      if (isElement(obj)) {\n        var s = \"<\" + $toLowerCase.call(String(obj.nodeName));\n        var attrs = obj.attributes || [];\n        for (var i = 0; i < attrs.length; i++) {\n          s += \" \" + attrs[i].name + \"=\" + wrapQuotes(quote(attrs[i].value), \"double\", opts);\n        }\n        s += \">\";\n        if (obj.childNodes && obj.childNodes.length) {\n          s += \"...\";\n        }\n        s += \"</\" + $toLowerCase.call(String(obj.nodeName)) + \">\";\n        return s;\n      }\n      if (isArray(obj)) {\n        if (obj.length === 0) {\n          return \"[]\";\n        }\n        var xs = arrObjKeys(obj, inspect3);\n        if (indent && !singleLineValues(xs)) {\n          return \"[\" + indentedJoin(xs, indent) + \"]\";\n        }\n        return \"[ \" + $join.call(xs, \", \") + \" ]\";\n      }\n      if (isError(obj)) {\n        var parts = arrObjKeys(obj, inspect3);\n        if (!(\"cause\" in Error.prototype) && \"cause\" in obj && !isEnumerable.call(obj, \"cause\")) {\n          return \"{ [\" + String(obj) + \"] \" + $join.call($concat.call(\"[cause]: \" + inspect3(obj.cause), parts), \", \") + \" }\";\n        }\n        if (parts.length === 0) {\n          return \"[\" + String(obj) + \"]\";\n        }\n        return \"{ [\" + String(obj) + \"] \" + $join.call(parts, \", \") + \" }\";\n      }\n      if (typeof obj === \"object\" && customInspect) {\n        if (inspectSymbol && typeof obj[inspectSymbol] === \"function\" && utilInspect) {\n          return utilInspect(obj, { depth: maxDepth - depth });\n        } else if (customInspect !== \"symbol\" && typeof obj.inspect === \"function\") {\n          return obj.inspect();\n        }\n      }\n      if (isMap(obj)) {\n        var mapParts = [];\n        if (mapForEach) {\n          mapForEach.call(obj, function(value, key) {\n            mapParts.push(inspect3(key, obj, true) + \" => \" + inspect3(value, obj));\n          });\n        }\n        return collectionOf(\"Map\", mapSize.call(obj), mapParts, indent);\n      }\n      if (isSet(obj)) {\n        var setParts = [];\n        if (setForEach) {\n          setForEach.call(obj, function(value) {\n            setParts.push(inspect3(value, obj));\n          });\n        }\n        return collectionOf(\"Set\", setSize.call(obj), setParts, indent);\n      }\n      if (isWeakMap(obj)) {\n        return weakCollectionOf(\"WeakMap\");\n      }\n      if (isWeakSet(obj)) {\n        return weakCollectionOf(\"WeakSet\");\n      }\n      if (isWeakRef(obj)) {\n        return weakCollectionOf(\"WeakRef\");\n      }\n      if (isNumber(obj)) {\n        return markBoxed(inspect3(Number(obj)));\n      }\n      if (isBigInt(obj)) {\n        return markBoxed(inspect3(bigIntValueOf.call(obj)));\n      }\n      if (isBoolean(obj)) {\n        return markBoxed(booleanValueOf.call(obj));\n      }\n      if (isString(obj)) {\n        return markBoxed(inspect3(String(obj)));\n      }\n      if (typeof window !== \"undefined\" && obj === window) {\n        return \"{ [object Window] }\";\n      }\n      if (typeof globalThis !== \"undefined\" && obj === globalThis || typeof global !== \"undefined\" && obj === global) {\n        return \"{ [object globalThis] }\";\n      }\n      if (!isDate(obj) && !isRegExp(obj)) {\n        var ys = arrObjKeys(obj, inspect3);\n        var isPlainObject = gPO ? gPO(obj) === Object.prototype : obj instanceof Object || obj.constructor === Object;\n        var protoTag = obj instanceof Object ? \"\" : \"null prototype\";\n        var stringTag = !isPlainObject && toStringTag && Object(obj) === obj && toStringTag in obj ? $slice.call(toStr(obj), 8, -1) : protoTag ? \"Object\" : \"\";\n        var constructorTag = isPlainObject || typeof obj.constructor !== \"function\" ? \"\" : obj.constructor.name ? obj.constructor.name + \" \" : \"\";\n        var tag = constructorTag + (stringTag || protoTag ? \"[\" + $join.call($concat.call([], stringTag || [], protoTag || []), \": \") + \"] \" : \"\");\n        if (ys.length === 0) {\n          return tag + \"{}\";\n        }\n        if (indent) {\n          return tag + \"{\" + indentedJoin(ys, indent) + \"}\";\n        }\n        return tag + \"{ \" + $join.call(ys, \", \") + \" }\";\n      }\n      return String(obj);\n    };\n    function wrapQuotes(s, defaultStyle, opts) {\n      var style = opts.quoteStyle || defaultStyle;\n      var quoteChar = quotes[style];\n      return quoteChar + s + quoteChar;\n    }\n    function quote(s) {\n      return $replace.call(String(s), /\"/g, \"&quot;\");\n    }\n    function canTrustToString(obj) {\n      return !toStringTag || !(typeof obj === \"object\" && (toStringTag in obj || typeof obj[toStringTag] !== \"undefined\"));\n    }\n    function isArray(obj) {\n      return toStr(obj) === \"[object Array]\" && canTrustToString(obj);\n    }\n    function isDate(obj) {\n      return toStr(obj) === \"[object Date]\" && canTrustToString(obj);\n    }\n    function isRegExp(obj) {\n      return toStr(obj) === \"[object RegExp]\" && canTrustToString(obj);\n    }\n    function isError(obj) {\n      return toStr(obj) === \"[object Error]\" && canTrustToString(obj);\n    }\n    function isString(obj) {\n      return toStr(obj) === \"[object String]\" && canTrustToString(obj);\n    }\n    function isNumber(obj) {\n      return toStr(obj) === \"[object Number]\" && canTrustToString(obj);\n    }\n    function isBoolean(obj) {\n      return toStr(obj) === \"[object Boolean]\" && canTrustToString(obj);\n    }\n    function isSymbol(obj) {\n      if (hasShammedSymbols) {\n        return obj && typeof obj === \"object\" && obj instanceof Symbol;\n      }\n      if (typeof obj === \"symbol\") {\n        return true;\n      }\n      if (!obj || typeof obj !== \"object\" || !symToString) {\n        return false;\n      }\n      try {\n        symToString.call(obj);\n        return true;\n      } catch (e) {\n      }\n      return false;\n    }\n    function isBigInt(obj) {\n      if (!obj || typeof obj !== \"object\" || !bigIntValueOf) {\n        return false;\n      }\n      try {\n        bigIntValueOf.call(obj);\n        return true;\n      } catch (e) {\n      }\n      return false;\n    }\n    var hasOwn2 = Object.prototype.hasOwnProperty || function(key) {\n      return key in this;\n    };\n    function has(obj, key) {\n      return hasOwn2.call(obj, key);\n    }\n    function toStr(obj) {\n      return objectToString.call(obj);\n    }\n    function nameOf(f) {\n      if (f.name) {\n        return f.name;\n      }\n      var m = $match.call(functionToString.call(f), /^function\\s*([\\w$]+)/);\n      if (m) {\n        return m[1];\n      }\n      return null;\n    }\n    function indexOf(xs, x) {\n      if (xs.indexOf) {\n        return xs.indexOf(x);\n      }\n      for (var i = 0, l = xs.length; i < l; i++) {\n        if (xs[i] === x) {\n          return i;\n        }\n      }\n      return -1;\n    }\n    function isMap(x) {\n      if (!mapSize || !x || typeof x !== \"object\") {\n        return false;\n      }\n      try {\n        mapSize.call(x);\n        try {\n          setSize.call(x);\n        } catch (s) {\n          return true;\n        }\n        return x instanceof Map;\n      } catch (e) {\n      }\n      return false;\n    }\n    function isWeakMap(x) {\n      if (!weakMapHas || !x || typeof x !== \"object\") {\n        return false;\n      }\n      try {\n        weakMapHas.call(x, weakMapHas);\n        try {\n          weakSetHas.call(x, weakSetHas);\n        } catch (s) {\n          return true;\n        }\n        return x instanceof WeakMap;\n      } catch (e) {\n      }\n      return false;\n    }\n    function isWeakRef(x) {\n      if (!weakRefDeref || !x || typeof x !== \"object\") {\n        return false;\n      }\n      try {\n        weakRefDeref.call(x);\n        return true;\n      } catch (e) {\n      }\n      return false;\n    }\n    function isSet(x) {\n      if (!setSize || !x || typeof x !== \"object\") {\n        return false;\n      }\n      try {\n        setSize.call(x);\n        try {\n          mapSize.call(x);\n        } catch (m) {\n          return true;\n        }\n        return x instanceof Set;\n      } catch (e) {\n      }\n      return false;\n    }\n    function isWeakSet(x) {\n      if (!weakSetHas || !x || typeof x !== \"object\") {\n        return false;\n      }\n      try {\n        weakSetHas.call(x, weakSetHas);\n        try {\n          weakMapHas.call(x, weakMapHas);\n        } catch (s) {\n          return true;\n        }\n        return x instanceof WeakSet;\n      } catch (e) {\n      }\n      return false;\n    }\n    function isElement(x) {\n      if (!x || typeof x !== \"object\") {\n        return false;\n      }\n      if (typeof HTMLElement !== \"undefined\" && x instanceof HTMLElement) {\n        return true;\n      }\n      return typeof x.nodeName === \"string\" && typeof x.getAttribute === \"function\";\n    }\n    function inspectString(str, opts) {\n      if (str.length > opts.maxStringLength) {\n        var remaining = str.length - opts.maxStringLength;\n        var trailer = \"... \" + remaining + \" more character\" + (remaining > 1 ? \"s\" : \"\");\n        return inspectString($slice.call(str, 0, opts.maxStringLength), opts) + trailer;\n      }\n      var quoteRE = quoteREs[opts.quoteStyle || \"single\"];\n      quoteRE.lastIndex = 0;\n      var s = $replace.call($replace.call(str, quoteRE, \"\\\\$1\"), /[\\x00-\\x1f]/g, lowbyte);\n      return wrapQuotes(s, \"single\", opts);\n    }\n    function lowbyte(c) {\n      var n = c.charCodeAt(0);\n      var x = {\n        8: \"b\",\n        9: \"t\",\n        10: \"n\",\n        12: \"f\",\n        13: \"r\"\n      }[n];\n      if (x) {\n        return \"\\\\\" + x;\n      }\n      return \"\\\\x\" + (n < 16 ? \"0\" : \"\") + $toUpperCase.call(n.toString(16));\n    }\n    function markBoxed(str) {\n      return \"Object(\" + str + \")\";\n    }\n    function weakCollectionOf(type) {\n      return type + \" { ? }\";\n    }\n    function collectionOf(type, size, entries, indent) {\n      var joinedEntries = indent ? indentedJoin(entries, indent) : $join.call(entries, \", \");\n      return type + \" (\" + size + \") {\" + joinedEntries + \"}\";\n    }\n    function singleLineValues(xs) {\n      for (var i = 0; i < xs.length; i++) {\n        if (indexOf(xs[i], \"\\n\") >= 0) {\n          return false;\n        }\n      }\n      return true;\n    }\n    function getIndent(opts, depth) {\n      var baseIndent;\n      if (opts.indent === \"\t\") {\n        baseIndent = \"\t\";\n      } else if (typeof opts.indent === \"number\" && opts.indent > 0) {\n        baseIndent = $join.call(Array(opts.indent + 1), \" \");\n      } else {\n        return null;\n      }\n      return {\n        base: baseIndent,\n        prev: $join.call(Array(depth + 1), baseIndent)\n      };\n    }\n    function indentedJoin(xs, indent) {\n      if (xs.length === 0) {\n        return \"\";\n      }\n      var lineJoiner = \"\\n\" + indent.prev + indent.base;\n      return lineJoiner + $join.call(xs, \",\" + lineJoiner) + \"\\n\" + indent.prev;\n    }\n    function arrObjKeys(obj, inspect3) {\n      var isArr = isArray(obj);\n      var xs = [];\n      if (isArr) {\n        xs.length = obj.length;\n        for (var i = 0; i < obj.length; i++) {\n          xs[i] = has(obj, i) ? inspect3(obj[i], obj) : \"\";\n        }\n      }\n      var syms = typeof gOPS === \"function\" ? gOPS(obj) : [];\n      var symMap;\n      if (hasShammedSymbols) {\n        symMap = {};\n        for (var k = 0; k < syms.length; k++) {\n          symMap[\"$\" + syms[k]] = syms[k];\n        }\n      }\n      for (var key in obj) {\n        if (!has(obj, key)) {\n          continue;\n        }\n        if (isArr && String(Number(key)) === key && key < obj.length) {\n          continue;\n        }\n        if (hasShammedSymbols && symMap[\"$\" + key] instanceof Symbol) {\n          continue;\n        } else if ($test.call(/[^\\w$]/, key)) {\n          xs.push(inspect3(key, obj) + \": \" + inspect3(obj[key], obj));\n        } else {\n          xs.push(key + \": \" + inspect3(obj[key], obj));\n        }\n      }\n      if (typeof gOPS === \"function\") {\n        for (var j = 0; j < syms.length; j++) {\n          if (isEnumerable.call(obj, syms[j])) {\n            xs.push(\"[\" + inspect3(syms[j]) + \"]: \" + inspect3(obj[syms[j]], obj));\n          }\n        }\n      }\n      return xs;\n    }\n  }\n});\n\n// src/lib/time_duration.ts\nvar TimeDuration = class _TimeDuration {\n  __time_duration_micros__;\n  static MICROS_PER_MILLIS = 1000n;\n  /**\n   * Get the algebraic type representation of the {@link TimeDuration} type.\n   * @returns The algebraic type representation of the type.\n   */\n  static getAlgebraicType() {\n    return AlgebraicType.Product({\n      elements: [\n        {\n          name: \"__time_duration_micros__\",\n          algebraicType: AlgebraicType.I64\n        }\n      ]\n    });\n  }\n  static isTimeDuration(algebraicType) {\n    if (algebraicType.tag !== \"Product\") {\n      return false;\n    }\n    const elements = algebraicType.value.elements;\n    if (elements.length !== 1) {\n      return false;\n    }\n    const microsElement = elements[0];\n    return microsElement.name === \"__time_duration_micros__\" && microsElement.algebraicType.tag === \"I64\";\n  }\n  get micros() {\n    return this.__time_duration_micros__;\n  }\n  get millis() {\n    return Number(this.micros / _TimeDuration.MICROS_PER_MILLIS);\n  }\n  constructor(micros) {\n    this.__time_duration_micros__ = micros;\n  }\n  static fromMillis(millis) {\n    return new _TimeDuration(BigInt(millis) * _TimeDuration.MICROS_PER_MILLIS);\n  }\n  /** This outputs the same string format that we use in the host and in Rust modules */\n  toString() {\n    const micros = this.micros;\n    const sign = micros < 0 ? \"-\" : \"+\";\n    const pos = micros < 0 ? -micros : micros;\n    const secs = pos / 1000000n;\n    const micros_remaining = pos % 1000000n;\n    return `${sign}${secs}.${String(micros_remaining).padStart(6, \"0\")}`;\n  }\n};\n\n// src/lib/timestamp.ts\nvar Timestamp = class _Timestamp {\n  __timestamp_micros_since_unix_epoch__;\n  static MICROS_PER_MILLIS = 1000n;\n  get microsSinceUnixEpoch() {\n    return this.__timestamp_micros_since_unix_epoch__;\n  }\n  constructor(micros) {\n    this.__timestamp_micros_since_unix_epoch__ = micros;\n  }\n  /**\n   * Get the algebraic type representation of the {@link Timestamp} type.\n   * @returns The algebraic type representation of the type.\n   */\n  static getAlgebraicType() {\n    return AlgebraicType.Product({\n      elements: [\n        {\n          name: \"__timestamp_micros_since_unix_epoch__\",\n          algebraicType: AlgebraicType.I64\n        }\n      ]\n    });\n  }\n  static isTimestamp(algebraicType) {\n    if (algebraicType.tag !== \"Product\") {\n      return false;\n    }\n    const elements = algebraicType.value.elements;\n    if (elements.length !== 1) {\n      return false;\n    }\n    const microsElement = elements[0];\n    return microsElement.name === \"__timestamp_micros_since_unix_epoch__\" && microsElement.algebraicType.tag === \"I64\";\n  }\n  /**\n   * The Unix epoch, the midnight at the beginning of January 1, 1970, UTC.\n   */\n  static UNIX_EPOCH = new _Timestamp(0n);\n  /**\n   * Get a `Timestamp` representing the execution environment's belief of the current moment in time.\n   */\n  static now() {\n    return _Timestamp.fromDate(/* @__PURE__ */ new Date());\n  }\n  /** Convert to milliseconds since Unix epoch. */\n  toMillis() {\n    return this.microsSinceUnixEpoch / 1000n;\n  }\n  /**\n   * Get a `Timestamp` representing the same point in time as `date`.\n   */\n  static fromDate(date) {\n    const millis = date.getTime();\n    const micros = BigInt(millis) * _Timestamp.MICROS_PER_MILLIS;\n    return new _Timestamp(micros);\n  }\n  /**\n   * Get a `Date` representing approximately the same point in time as `this`.\n   *\n   * This method truncates to millisecond precision,\n   * and throws `RangeError` if the `Timestamp` is outside the range representable as a `Date`.\n   */\n  toDate() {\n    const micros = this.__timestamp_micros_since_unix_epoch__;\n    const millis = micros / _Timestamp.MICROS_PER_MILLIS;\n    if (millis > BigInt(Number.MAX_SAFE_INTEGER) || millis < BigInt(Number.MIN_SAFE_INTEGER)) {\n      throw new RangeError(\n        \"Timestamp is outside of the representable range of JS's Date\"\n      );\n    }\n    return new Date(Number(millis));\n  }\n  /**\n   * Get an ISO 8601 / RFC 3339 formatted string representation of this timestamp with microsecond precision.\n   *\n   * This method preserves the full microsecond precision of the timestamp,\n   * and throws `RangeError` if the `Timestamp` is outside the range representable in ISO format.\n   *\n   * @returns ISO 8601 formatted string with microsecond precision (e.g., '2025-02-17T10:30:45.123456Z')\n   */\n  toISOString() {\n    const micros = this.__timestamp_micros_since_unix_epoch__;\n    const millis = micros / _Timestamp.MICROS_PER_MILLIS;\n    if (millis > BigInt(Number.MAX_SAFE_INTEGER) || millis < BigInt(Number.MIN_SAFE_INTEGER)) {\n      throw new RangeError(\n        \"Timestamp is outside of the representable range for ISO string formatting\"\n      );\n    }\n    const date = new Date(Number(millis));\n    const isoBase = date.toISOString();\n    const microsRemainder = Math.abs(Number(micros % 1000000n));\n    const fractionalPart = String(microsRemainder).padStart(6, \"0\");\n    return isoBase.replace(/\\.\\d{3}Z$/, `.${fractionalPart}Z`);\n  }\n  since(other) {\n    return new TimeDuration(\n      this.__timestamp_micros_since_unix_epoch__ - other.__timestamp_micros_since_unix_epoch__\n    );\n  }\n};\n\n// src/lib/uuid.ts\nvar Uuid = class _Uuid {\n  __uuid__;\n  /**\n   * The nil UUID (all zeros).\n   *\n   * @example\n   * ```ts\n   * const uuid = Uuid.NIL;\n   * console.assert(\n   *   uuid.toString() === \"00000000-0000-0000-0000-000000000000\"\n   * );\n   * ```\n   */\n  static NIL = new _Uuid(0n);\n  static MAX_UUID_BIGINT = 0xffffffffffffffffffffffffffffffffn;\n  /**\n   * The max UUID (all ones).\n   *\n   * @example\n   * ```ts\n   * const uuid = Uuid.MAX;\n   * console.assert(\n   *   uuid.toString() === \"ffffffff-ffff-ffff-ffff-ffffffffffff\"\n   * );\n   * ```\n   */\n  static MAX = new _Uuid(_Uuid.MAX_UUID_BIGINT);\n  /**\n   * Create a UUID from a raw 128-bit value.\n   *\n   * @param u - Unsigned 128-bit integer\n   * @throws {Error} If the value is outside the valid UUID range\n   */\n  constructor(u) {\n    if (u < 0n || u > _Uuid.MAX_UUID_BIGINT) {\n      throw new Error(\"Invalid UUID: must be between 0 and `MAX_UUID_BIGINT`\");\n    }\n    this.__uuid__ = u;\n  }\n  /**\n   * Create a UUID `v4` from explicit random bytes.\n   *\n   * This method assumes the bytes are already sufficiently random.\n   * It only sets the appropriate bits for the UUID version and variant.\n   *\n   * @param bytes - Exactly 16 random bytes\n   * @returns A UUID `v4`\n   * @throws {Error} If `bytes.length !== 16`\n   *\n   * @example\n   * ```ts\n   * const randomBytes = new Uint8Array(16);\n   * const uuid = Uuid.fromRandomBytesV4(randomBytes);\n   *\n   * console.assert(\n   *   uuid.toString() === \"00000000-0000-4000-8000-000000000000\"\n   * );\n   * ```\n   */\n  static fromRandomBytesV4(bytes) {\n    if (bytes.length !== 16) throw new Error(\"UUID v4 requires 16 bytes\");\n    const arr = new Uint8Array(bytes);\n    arr[6] = arr[6] & 15 | 64;\n    arr[8] = arr[8] & 63 | 128;\n    return new _Uuid(_Uuid.bytesToBigInt(arr));\n  }\n  /**\n   * Generate a UUID `v7` using a monotonic counter from `0` to `2^31 - 1`,\n   * a timestamp, and 4 random bytes.\n   *\n   * The counter wraps around on overflow.\n   *\n   * The UUID `v7` is structured as follows:\n   *\n   * ```ascii\n   * ┌───────────────────────────────────────────────┬───────────────────┐\n   * | B0  | B1  | B2  | B3  | B4  | B5              |         B6        |\n   * ├───────────────────────────────────────────────┼───────────────────┤\n   * |                 unix_ts_ms                    |      version 7    |\n   * └───────────────────────────────────────────────┴───────────────────┘\n   * ┌──────────────┬─────────┬──────────────────┬───────────────────────┐\n   * | B7           | B8      | B9  | B10 | B11  | B12 | B13 | B14 | B15 |\n   * ├──────────────┼─────────┼──────────────────┼───────────────────────┤\n   * | counter_high | variant |    counter_low   |        random         |\n   * └──────────────┴─────────┴──────────────────┴───────────────────────┘\n   * ```\n   *\n   * @param counter - Mutable monotonic counter (31-bit)\n   * @param now - Timestamp since the Unix epoch\n   * @param randomBytes - Exactly 4 random bytes\n   * @returns A UUID `v7`\n   *\n   * @throws {Error} If the `counter` is negative\n   * @throws {Error} If the `timestamp` is before the Unix epoch\n   * @throws {Error} If `randomBytes.length !== 4`\n   *\n   * @example\n   * ```ts\n   * const now = Timestamp.fromMillis(1_686_000_000_000n);\n   * const counter = { value: 1 };\n   * const randomBytes = new Uint8Array(4);\n   *\n   * const uuid = Uuid.fromCounterV7(counter, now, randomBytes);\n   *\n   * console.assert(\n   *   uuid.toString() === \"0000647e-5180-7000-8000-000200000000\"\n   * );\n   * ```\n   */\n  static fromCounterV7(counter, now, randomBytes) {\n    if (randomBytes.length !== 4) {\n      throw new Error(\"`fromCounterV7` requires `randomBytes.length == 4`\");\n    }\n    if (counter.value < 0) {\n      throw new Error(\"`fromCounterV7` uuid `counter` must be non-negative\");\n    }\n    if (now.__timestamp_micros_since_unix_epoch__ < 0) {\n      throw new Error(\"`fromCounterV7` `timestamp` before unix epoch\");\n    }\n    const counterVal = counter.value;\n    counter.value = counterVal + 1 & 2147483647;\n    const tsMs = now.toMillis() & 0xffffffffffffn;\n    const bytes = new Uint8Array(16);\n    bytes[0] = Number(tsMs >> 40n & 0xffn);\n    bytes[1] = Number(tsMs >> 32n & 0xffn);\n    bytes[2] = Number(tsMs >> 24n & 0xffn);\n    bytes[3] = Number(tsMs >> 16n & 0xffn);\n    bytes[4] = Number(tsMs >> 8n & 0xffn);\n    bytes[5] = Number(tsMs & 0xffn);\n    bytes[7] = counterVal >>> 23 & 255;\n    bytes[9] = counterVal >>> 15 & 255;\n    bytes[10] = counterVal >>> 7 & 255;\n    bytes[11] = (counterVal & 127) << 1 & 255;\n    bytes[12] |= randomBytes[0] & 127;\n    bytes[13] = randomBytes[1];\n    bytes[14] = randomBytes[2];\n    bytes[15] = randomBytes[3];\n    bytes[6] = bytes[6] & 15 | 112;\n    bytes[8] = bytes[8] & 63 | 128;\n    return new _Uuid(_Uuid.bytesToBigInt(bytes));\n  }\n  /**\n   * Parse a UUID from a string representation.\n   *\n   * @param s - UUID string\n   * @returns Parsed UUID\n   * @throws {Error} If the string is not a valid UUID\n   *\n   * @example\n   * ```ts\n   * const s = \"01888d6e-5c00-7000-8000-000000000000\";\n   * const uuid = Uuid.parse(s);\n   *\n   * console.assert(uuid.toString() === s);\n   * ```\n   */\n  static parse(s) {\n    const hex = s.replace(/-/g, \"\");\n    if (hex.length !== 32) throw new Error(\"Invalid hex UUID\");\n    let v = 0n;\n    for (let i = 0; i < 32; i += 2) {\n      v = v << 8n | BigInt(parseInt(hex.slice(i, i + 2), 16));\n    }\n    return new _Uuid(v);\n  }\n  /** Convert to string (hyphenated form). */\n  toString() {\n    const bytes = _Uuid.bigIntToBytes(this.__uuid__);\n    const hex = [...bytes].map((b) => b.toString(16).padStart(2, \"0\")).join(\"\");\n    return hex.slice(0, 8) + \"-\" + hex.slice(8, 12) + \"-\" + hex.slice(12, 16) + \"-\" + hex.slice(16, 20) + \"-\" + hex.slice(20);\n  }\n  /** Convert to bigint (u128). */\n  asBigInt() {\n    return this.__uuid__;\n  }\n  /** Return a `Uint8Array` of 16 bytes. */\n  toBytes() {\n    return _Uuid.bigIntToBytes(this.__uuid__);\n  }\n  static bytesToBigInt(bytes) {\n    let result = 0n;\n    for (const b of bytes) result = result << 8n | BigInt(b);\n    return result;\n  }\n  static bigIntToBytes(value) {\n    const bytes = new Uint8Array(16);\n    for (let i = 15; i >= 0; i--) {\n      bytes[i] = Number(value & 0xffn);\n      value >>= 8n;\n    }\n    return bytes;\n  }\n  /**\n   * Returns the version of this UUID.\n   *\n   * This represents the algorithm used to generate the value.\n   *\n   * @returns A `UuidVersion`\n   * @throws {Error} If the version field is not recognized\n   */\n  getVersion() {\n    const version = this.toBytes()[6] >> 4 & 15;\n    switch (version) {\n      case 4:\n        return \"V4\";\n      case 7:\n        return \"V7\";\n      default:\n        if (this == _Uuid.NIL) {\n          return \"Nil\";\n        }\n        if (this == _Uuid.MAX) {\n          return \"Max\";\n        }\n        throw new Error(`Unsupported UUID version: ${version}`);\n    }\n  }\n  /**\n   * Extract the monotonic counter from a UUIDv7.\n   *\n   * Intended for testing and diagnostics.\n   * Behavior is undefined if called on a non-V7 UUID.\n   *\n   * @returns 31-bit counter value\n   */\n  getCounter() {\n    const bytes = this.toBytes();\n    const high = bytes[7];\n    const mid1 = bytes[9];\n    const mid2 = bytes[10];\n    const low = bytes[11] >>> 1;\n    return high << 23 | mid1 << 15 | mid2 << 7 | low | 0;\n  }\n  compareTo(other) {\n    if (this.__uuid__ < other.__uuid__) return -1;\n    if (this.__uuid__ > other.__uuid__) return 1;\n    return 0;\n  }\n  static getAlgebraicType() {\n    return AlgebraicType.Product({\n      elements: [\n        {\n          name: \"__uuid__\",\n          algebraicType: AlgebraicType.U128\n        }\n      ]\n    });\n  }\n};\n\n// src/lib/binary_reader.ts\nvar BinaryReader = class {\n  /**\n   * The DataView used to read values from the binary data.\n   *\n   * Note: The DataView's `byteOffset` is relative to the beginning of the\n   * underlying ArrayBuffer, not the start of the provided Uint8Array input.\n   * This `BinaryReader`'s `#offset` field is used to track the current read position\n   * relative to the start of the provided Uint8Array input.\n   */\n  view;\n  /**\n   * Represents the offset (in bytes) relative to the start of the DataView\n   * and provided Uint8Array input.\n   *\n   * Note: This is *not* the absolute byte offset within the underlying ArrayBuffer.\n   */\n  offset = 0;\n  constructor(input) {\n    this.view = input instanceof DataView ? input : new DataView(input.buffer, input.byteOffset, input.byteLength);\n    this.offset = 0;\n  }\n  reset(view) {\n    this.view = view;\n    this.offset = 0;\n  }\n  get remaining() {\n    return this.view.byteLength - this.offset;\n  }\n  /** Ensure we have at least `n` bytes left to read */\n  #ensure(n) {\n    if (this.offset + n > this.view.byteLength) {\n      throw new RangeError(\n        `Tried to read ${n} byte(s) at relative offset ${this.offset}, but only ${this.remaining} byte(s) remain`\n      );\n    }\n  }\n  readUInt8Array() {\n    const length = this.readU32();\n    this.#ensure(length);\n    return this.readBytes(length);\n  }\n  readBool() {\n    const value = this.view.getUint8(this.offset);\n    this.offset += 1;\n    return value !== 0;\n  }\n  readByte() {\n    const value = this.view.getUint8(this.offset);\n    this.offset += 1;\n    return value;\n  }\n  readBytes(length) {\n    const array = new Uint8Array(\n      this.view.buffer,\n      this.view.byteOffset + this.offset,\n      length\n    );\n    this.offset += length;\n    return array;\n  }\n  readI8() {\n    const value = this.view.getInt8(this.offset);\n    this.offset += 1;\n    return value;\n  }\n  readU8() {\n    return this.readByte();\n  }\n  readI16() {\n    const value = this.view.getInt16(this.offset, true);\n    this.offset += 2;\n    return value;\n  }\n  readU16() {\n    const value = this.view.getUint16(this.offset, true);\n    this.offset += 2;\n    return value;\n  }\n  readI32() {\n    const value = this.view.getInt32(this.offset, true);\n    this.offset += 4;\n    return value;\n  }\n  readU32() {\n    const value = this.view.getUint32(this.offset, true);\n    this.offset += 4;\n    return value;\n  }\n  readI64() {\n    const value = this.view.getBigInt64(this.offset, true);\n    this.offset += 8;\n    return value;\n  }\n  readU64() {\n    const value = this.view.getBigUint64(this.offset, true);\n    this.offset += 8;\n    return value;\n  }\n  readU128() {\n    const lowerPart = this.view.getBigUint64(this.offset, true);\n    const upperPart = this.view.getBigUint64(this.offset + 8, true);\n    this.offset += 16;\n    return (upperPart << BigInt(64)) + lowerPart;\n  }\n  readI128() {\n    const lowerPart = this.view.getBigUint64(this.offset, true);\n    const upperPart = this.view.getBigInt64(this.offset + 8, true);\n    this.offset += 16;\n    return (upperPart << BigInt(64)) + lowerPart;\n  }\n  readU256() {\n    const p0 = this.view.getBigUint64(this.offset, true);\n    const p1 = this.view.getBigUint64(this.offset + 8, true);\n    const p2 = this.view.getBigUint64(this.offset + 16, true);\n    const p3 = this.view.getBigUint64(this.offset + 24, true);\n    this.offset += 32;\n    return (p3 << BigInt(3 * 64)) + (p2 << BigInt(2 * 64)) + (p1 << BigInt(1 * 64)) + p0;\n  }\n  readI256() {\n    const p0 = this.view.getBigUint64(this.offset, true);\n    const p1 = this.view.getBigUint64(this.offset + 8, true);\n    const p2 = this.view.getBigUint64(this.offset + 16, true);\n    const p3 = this.view.getBigInt64(this.offset + 24, true);\n    this.offset += 32;\n    return (p3 << BigInt(3 * 64)) + (p2 << BigInt(2 * 64)) + (p1 << BigInt(1 * 64)) + p0;\n  }\n  readF32() {\n    const value = this.view.getFloat32(this.offset, true);\n    this.offset += 4;\n    return value;\n  }\n  readF64() {\n    const value = this.view.getFloat64(this.offset, true);\n    this.offset += 8;\n    return value;\n  }\n  readString() {\n    const uint8Array = this.readUInt8Array();\n    return new TextDecoder(\"utf-8\").decode(uint8Array);\n  }\n};\n\n// src/lib/binary_writer.ts\nvar import_base64_js = __toESM(require_base64_js());\nvar ArrayBufferPrototypeTransfer = ArrayBuffer.prototype.transfer ?? function(newByteLength) {\n  if (newByteLength === void 0) {\n    return this.slice();\n  } else if (newByteLength <= this.byteLength) {\n    return this.slice(0, newByteLength);\n  } else {\n    const copy = new Uint8Array(newByteLength);\n    copy.set(new Uint8Array(this));\n    return copy.buffer;\n  }\n};\nvar ResizableBuffer = class {\n  buffer;\n  view;\n  constructor(init) {\n    this.buffer = typeof init === \"number\" ? new ArrayBuffer(init) : init;\n    this.view = new DataView(this.buffer);\n  }\n  get capacity() {\n    return this.buffer.byteLength;\n  }\n  grow(newSize) {\n    if (newSize <= this.buffer.byteLength) return;\n    this.buffer = ArrayBufferPrototypeTransfer.call(this.buffer, newSize);\n    this.view = new DataView(this.buffer);\n  }\n};\nvar BinaryWriter = class {\n  buffer;\n  offset = 0;\n  constructor(init) {\n    this.buffer = typeof init === \"number\" ? new ResizableBuffer(init) : init;\n  }\n  clear() {\n    this.offset = 0;\n  }\n  reset(buffer) {\n    this.buffer = buffer;\n    this.offset = 0;\n  }\n  expandBuffer(additionalCapacity) {\n    const minCapacity = this.offset + additionalCapacity + 1;\n    if (minCapacity <= this.buffer.capacity) return;\n    let newCapacity = this.buffer.capacity * 2;\n    if (newCapacity < minCapacity) newCapacity = minCapacity;\n    this.buffer.grow(newCapacity);\n  }\n  toBase64() {\n    return (0, import_base64_js.fromByteArray)(this.getBuffer());\n  }\n  getBuffer() {\n    return new Uint8Array(this.buffer.buffer, 0, this.offset);\n  }\n  get view() {\n    return this.buffer.view;\n  }\n  writeUInt8Array(value) {\n    const length = value.length;\n    this.expandBuffer(4 + length);\n    this.writeU32(length);\n    new Uint8Array(this.buffer.buffer, this.offset).set(value);\n    this.offset += length;\n  }\n  writeBool(value) {\n    this.expandBuffer(1);\n    this.view.setUint8(this.offset, value ? 1 : 0);\n    this.offset += 1;\n  }\n  writeByte(value) {\n    this.expandBuffer(1);\n    this.view.setUint8(this.offset, value);\n    this.offset += 1;\n  }\n  writeI8(value) {\n    this.expandBuffer(1);\n    this.view.setInt8(this.offset, value);\n    this.offset += 1;\n  }\n  writeU8(value) {\n    this.expandBuffer(1);\n    this.view.setUint8(this.offset, value);\n    this.offset += 1;\n  }\n  writeI16(value) {\n    this.expandBuffer(2);\n    this.view.setInt16(this.offset, value, true);\n    this.offset += 2;\n  }\n  writeU16(value) {\n    this.expandBuffer(2);\n    this.view.setUint16(this.offset, value, true);\n    this.offset += 2;\n  }\n  writeI32(value) {\n    this.expandBuffer(4);\n    this.view.setInt32(this.offset, value, true);\n    this.offset += 4;\n  }\n  writeU32(value) {\n    this.expandBuffer(4);\n    this.view.setUint32(this.offset, value, true);\n    this.offset += 4;\n  }\n  writeI64(value) {\n    this.expandBuffer(8);\n    this.view.setBigInt64(this.offset, value, true);\n    this.offset += 8;\n  }\n  writeU64(value) {\n    this.expandBuffer(8);\n    this.view.setBigUint64(this.offset, value, true);\n    this.offset += 8;\n  }\n  writeU128(value) {\n    this.expandBuffer(16);\n    const lowerPart = value & BigInt(\"0xFFFFFFFFFFFFFFFF\");\n    const upperPart = value >> BigInt(64);\n    this.view.setBigUint64(this.offset, lowerPart, true);\n    this.view.setBigUint64(this.offset + 8, upperPart, true);\n    this.offset += 16;\n  }\n  writeI128(value) {\n    this.expandBuffer(16);\n    const lowerPart = value & BigInt(\"0xFFFFFFFFFFFFFFFF\");\n    const upperPart = value >> BigInt(64);\n    this.view.setBigInt64(this.offset, lowerPart, true);\n    this.view.setBigInt64(this.offset + 8, upperPart, true);\n    this.offset += 16;\n  }\n  writeU256(value) {\n    this.expandBuffer(32);\n    const low_64_mask = BigInt(\"0xFFFFFFFFFFFFFFFF\");\n    const p0 = value & low_64_mask;\n    const p1 = value >> BigInt(64 * 1) & low_64_mask;\n    const p2 = value >> BigInt(64 * 2) & low_64_mask;\n    const p3 = value >> BigInt(64 * 3);\n    this.view.setBigUint64(this.offset + 8 * 0, p0, true);\n    this.view.setBigUint64(this.offset + 8 * 1, p1, true);\n    this.view.setBigUint64(this.offset + 8 * 2, p2, true);\n    this.view.setBigUint64(this.offset + 8 * 3, p3, true);\n    this.offset += 32;\n  }\n  writeI256(value) {\n    this.expandBuffer(32);\n    const low_64_mask = BigInt(\"0xFFFFFFFFFFFFFFFF\");\n    const p0 = value & low_64_mask;\n    const p1 = value >> BigInt(64 * 1) & low_64_mask;\n    const p2 = value >> BigInt(64 * 2) & low_64_mask;\n    const p3 = value >> BigInt(64 * 3);\n    this.view.setBigUint64(this.offset + 8 * 0, p0, true);\n    this.view.setBigUint64(this.offset + 8 * 1, p1, true);\n    this.view.setBigUint64(this.offset + 8 * 2, p2, true);\n    this.view.setBigInt64(this.offset + 8 * 3, p3, true);\n    this.offset += 32;\n  }\n  writeF32(value) {\n    this.expandBuffer(4);\n    this.view.setFloat32(this.offset, value, true);\n    this.offset += 4;\n  }\n  writeF64(value) {\n    this.expandBuffer(8);\n    this.view.setFloat64(this.offset, value, true);\n    this.offset += 8;\n  }\n  writeString(value) {\n    const encoder = new TextEncoder();\n    const encodedString = encoder.encode(value);\n    this.writeUInt8Array(encodedString);\n  }\n};\n\n// src/lib/util.ts\nfunction uint8ArrayToHexString(array) {\n  return Array.prototype.map.call(array.reverse(), (x) => (\"00\" + x.toString(16)).slice(-2)).join(\"\");\n}\nfunction uint8ArrayToU128(array) {\n  if (array.length != 16) {\n    throw new Error(`Uint8Array is not 16 bytes long: ${array}`);\n  }\n  return new BinaryReader(array).readU128();\n}\nfunction uint8ArrayToU256(array) {\n  if (array.length != 32) {\n    throw new Error(`Uint8Array is not 32 bytes long: [${array}]`);\n  }\n  return new BinaryReader(array).readU256();\n}\nfunction hexStringToUint8Array(str) {\n  if (str.startsWith(\"0x\")) {\n    str = str.slice(2);\n  }\n  const matches = str.match(/.{1,2}/g) || [];\n  const data = Uint8Array.from(\n    matches.map((byte) => parseInt(byte, 16))\n  );\n  return data.reverse();\n}\nfunction hexStringToU128(str) {\n  return uint8ArrayToU128(hexStringToUint8Array(str));\n}\nfunction hexStringToU256(str) {\n  return uint8ArrayToU256(hexStringToUint8Array(str));\n}\nfunction u128ToUint8Array(data) {\n  const writer = new BinaryWriter(16);\n  writer.writeU128(data);\n  return writer.getBuffer();\n}\nfunction u128ToHexString(data) {\n  return uint8ArrayToHexString(u128ToUint8Array(data));\n}\nfunction u256ToUint8Array(data) {\n  const writer = new BinaryWriter(32);\n  writer.writeU256(data);\n  return writer.getBuffer();\n}\nfunction u256ToHexString(data) {\n  return uint8ArrayToHexString(u256ToUint8Array(data));\n}\nfunction toPascalCase(s) {\n  const str = toCamelCase(s);\n  return str.charAt(0).toUpperCase() + str.slice(1);\n}\nfunction toCamelCase(s) {\n  const str = s.replace(/[-_]+/g, \"_\").replace(/_([a-zA-Z0-9])/g, (_, c) => c.toUpperCase());\n  return str.charAt(0).toLowerCase() + str.slice(1);\n}\nfunction bsatnBaseSize(typespace, ty) {\n  const assumedArrayLength = 4;\n  while (ty.tag === \"Ref\") ty = typespace.types[ty.value];\n  if (ty.tag === \"Product\") {\n    let sum = 0;\n    for (const { algebraicType: elem } of ty.value.elements) {\n      sum += bsatnBaseSize(typespace, elem);\n    }\n    return sum;\n  } else if (ty.tag === \"Sum\") {\n    let min = Infinity;\n    for (const { algebraicType: vari } of ty.value.variants) {\n      const vSize = bsatnBaseSize(typespace, vari);\n      if (vSize < min) min = vSize;\n    }\n    if (min === Infinity) min = 0;\n    return 4 + min;\n  } else if (ty.tag == \"Array\") {\n    return 4 + assumedArrayLength * bsatnBaseSize(typespace, ty.value);\n  }\n  return {\n    String: 4 + assumedArrayLength,\n    Sum: 1,\n    Bool: 1,\n    I8: 1,\n    U8: 1,\n    I16: 2,\n    U16: 2,\n    I32: 4,\n    U32: 4,\n    F32: 4,\n    I64: 8,\n    U64: 8,\n    F64: 8,\n    I128: 16,\n    U128: 16,\n    I256: 32,\n    U256: 32\n  }[ty.tag];\n}\nvar hasOwn = Object.hasOwn;\n\n// src/lib/connection_id.ts\nvar ConnectionId = class _ConnectionId {\n  __connection_id__;\n  /**\n   * Creates a new `ConnectionId`.\n   */\n  constructor(data) {\n    this.__connection_id__ = data;\n  }\n  /**\n   * Get the algebraic type representation of the {@link ConnectionId} type.\n   * @returns The algebraic type representation of the type.\n   */\n  static getAlgebraicType() {\n    return AlgebraicType.Product({\n      elements: [\n        { name: \"__connection_id__\", algebraicType: AlgebraicType.U128 }\n      ]\n    });\n  }\n  isZero() {\n    return this.__connection_id__ === BigInt(0);\n  }\n  static nullIfZero(addr) {\n    if (addr.isZero()) {\n      return null;\n    } else {\n      return addr;\n    }\n  }\n  static random() {\n    function randomU8() {\n      return Math.floor(Math.random() * 255);\n    }\n    let result = BigInt(0);\n    for (let i = 0; i < 16; i++) {\n      result = result << BigInt(8) | BigInt(randomU8());\n    }\n    return new _ConnectionId(result);\n  }\n  /**\n   * Compare two connection IDs for equality.\n   */\n  isEqual(other) {\n    return this.__connection_id__ == other.__connection_id__;\n  }\n  /**\n   * Check if two connection IDs are equal.\n   */\n  equals(other) {\n    return this.isEqual(other);\n  }\n  /**\n   * Print the connection ID as a hexadecimal string.\n   */\n  toHexString() {\n    return u128ToHexString(this.__connection_id__);\n  }\n  /**\n   * Convert the connection ID to a Uint8Array.\n   */\n  toUint8Array() {\n    return u128ToUint8Array(this.__connection_id__);\n  }\n  /**\n   * Parse a connection ID from a hexadecimal string.\n   */\n  static fromString(str) {\n    return new _ConnectionId(hexStringToU128(str));\n  }\n  static fromStringOrNull(str) {\n    const addr = _ConnectionId.fromString(str);\n    if (addr.isZero()) {\n      return null;\n    } else {\n      return addr;\n    }\n  }\n};\n\n// src/lib/identity.ts\nvar Identity = class _Identity {\n  __identity__;\n  /**\n   * Creates a new `Identity`.\n   *\n   * `data` can be a hexadecimal string or a `bigint`.\n   */\n  constructor(data) {\n    this.__identity__ = typeof data === \"string\" ? hexStringToU256(data) : data;\n  }\n  /**\n   * Get the algebraic type representation of the {@link Identity} type.\n   * @returns The algebraic type representation of the type.\n   */\n  static getAlgebraicType() {\n    return AlgebraicType.Product({\n      elements: [{ name: \"__identity__\", algebraicType: AlgebraicType.U256 }]\n    });\n  }\n  /**\n   * Check if two identities are equal.\n   */\n  isEqual(other) {\n    return this.toHexString() === other.toHexString();\n  }\n  /**\n   * Check if two identities are equal.\n   */\n  equals(other) {\n    return this.isEqual(other);\n  }\n  /**\n   * Print the identity as a hexadecimal string.\n   */\n  toHexString() {\n    return u256ToHexString(this.__identity__);\n  }\n  /**\n   * Convert the address to a Uint8Array.\n   */\n  toUint8Array() {\n    return u256ToUint8Array(this.__identity__);\n  }\n  /**\n   * Parse an Identity from a hexadecimal string.\n   */\n  static fromString(str) {\n    return new _Identity(str);\n  }\n  /**\n   * Zero identity (0x0000000000000000000000000000000000000000000000000000000000000000)\n   */\n  static zero() {\n    return new _Identity(0n);\n  }\n  toString() {\n    return this.toHexString();\n  }\n};\n\n// src/lib/algebraic_type.ts\nvar SERIALIZERS = /* @__PURE__ */ new Map();\nvar DESERIALIZERS = /* @__PURE__ */ new Map();\nvar AlgebraicType = {\n  Ref: (value) => ({ tag: \"Ref\", value }),\n  Sum: (value) => ({\n    tag: \"Sum\",\n    value\n  }),\n  Product: (value) => ({\n    tag: \"Product\",\n    value\n  }),\n  Array: (value) => ({\n    tag: \"Array\",\n    value\n  }),\n  String: { tag: \"String\" },\n  Bool: { tag: \"Bool\" },\n  I8: { tag: \"I8\" },\n  U8: { tag: \"U8\" },\n  I16: { tag: \"I16\" },\n  U16: { tag: \"U16\" },\n  I32: { tag: \"I32\" },\n  U32: { tag: \"U32\" },\n  I64: { tag: \"I64\" },\n  U64: { tag: \"U64\" },\n  I128: { tag: \"I128\" },\n  U128: { tag: \"U128\" },\n  I256: { tag: \"I256\" },\n  U256: { tag: \"U256\" },\n  F32: { tag: \"F32\" },\n  F64: { tag: \"F64\" },\n  makeSerializer(ty, typespace) {\n    if (ty.tag === \"Ref\") {\n      if (!typespace)\n        throw new Error(\"cannot serialize refs without a typespace\");\n      while (ty.tag === \"Ref\") ty = typespace.types[ty.value];\n    }\n    switch (ty.tag) {\n      case \"Product\":\n        return ProductType.makeSerializer(ty.value, typespace);\n      case \"Sum\":\n        return SumType.makeSerializer(ty.value, typespace);\n      case \"Array\":\n        if (ty.value.tag === \"U8\") {\n          return serializeUint8Array;\n        } else {\n          const serialize = AlgebraicType.makeSerializer(ty.value, typespace);\n          return (writer, value) => {\n            writer.writeU32(value.length);\n            for (const elem of value) {\n              serialize(writer, elem);\n            }\n          };\n        }\n      default:\n        return primitiveSerializers[ty.tag];\n    }\n  },\n  /** @deprecated Use `makeSerializer` instead. */\n  serializeValue(writer, ty, value, typespace) {\n    AlgebraicType.makeSerializer(ty, typespace)(writer, value);\n  },\n  makeDeserializer(ty, typespace) {\n    if (ty.tag === \"Ref\") {\n      if (!typespace)\n        throw new Error(\"cannot deserialize refs without a typespace\");\n      while (ty.tag === \"Ref\") ty = typespace.types[ty.value];\n    }\n    switch (ty.tag) {\n      case \"Product\":\n        return ProductType.makeDeserializer(ty.value, typespace);\n      case \"Sum\":\n        return SumType.makeDeserializer(ty.value, typespace);\n      case \"Array\":\n        if (ty.value.tag === \"U8\") {\n          return deserializeUint8Array;\n        } else {\n          const deserialize = AlgebraicType.makeDeserializer(\n            ty.value,\n            typespace\n          );\n          return (reader) => {\n            const length = reader.readU32();\n            const result = Array(length);\n            for (let i = 0; i < length; i++) {\n              result[i] = deserialize(reader);\n            }\n            return result;\n          };\n        }\n      default:\n        return primitiveDeserializers[ty.tag];\n    }\n  },\n  /** @deprecated Use `makeDeserializer` instead. */\n  deserializeValue(reader, ty, typespace) {\n    return AlgebraicType.makeDeserializer(ty, typespace)(reader);\n  },\n  /**\n   * Convert a value of the algebraic type into something that can be used as a key in a map.\n   * There are no guarantees about being able to order it.\n   * This is only guaranteed to be comparable to other values of the same type.\n   * @param value A value of the algebraic type\n   * @returns Something that can be used as a key in a map.\n   */\n  intoMapKey: function(ty, value) {\n    switch (ty.tag) {\n      case \"U8\":\n      case \"U16\":\n      case \"U32\":\n      case \"U64\":\n      case \"U128\":\n      case \"U256\":\n      case \"I8\":\n      case \"I16\":\n      case \"I32\":\n      case \"I64\":\n      case \"I128\":\n      case \"I256\":\n      case \"F32\":\n      case \"F64\":\n      case \"String\":\n      case \"Bool\":\n        return value;\n      case \"Product\":\n        return ProductType.intoMapKey(ty.value, value);\n      default: {\n        const writer = new BinaryWriter(10);\n        AlgebraicType.serializeValue(writer, ty, value);\n        return writer.toBase64();\n      }\n    }\n  }\n};\nfunction bindCall(f) {\n  return Function.prototype.call.bind(f);\n}\nvar primitiveSerializers = {\n  Bool: bindCall(BinaryWriter.prototype.writeBool),\n  I8: bindCall(BinaryWriter.prototype.writeI8),\n  U8: bindCall(BinaryWriter.prototype.writeU8),\n  I16: bindCall(BinaryWriter.prototype.writeI16),\n  U16: bindCall(BinaryWriter.prototype.writeU16),\n  I32: bindCall(BinaryWriter.prototype.writeI32),\n  U32: bindCall(BinaryWriter.prototype.writeU32),\n  I64: bindCall(BinaryWriter.prototype.writeI64),\n  U64: bindCall(BinaryWriter.prototype.writeU64),\n  I128: bindCall(BinaryWriter.prototype.writeI128),\n  U128: bindCall(BinaryWriter.prototype.writeU128),\n  I256: bindCall(BinaryWriter.prototype.writeI256),\n  U256: bindCall(BinaryWriter.prototype.writeU256),\n  F32: bindCall(BinaryWriter.prototype.writeF32),\n  F64: bindCall(BinaryWriter.prototype.writeF64),\n  String: bindCall(BinaryWriter.prototype.writeString)\n};\nObject.freeze(primitiveSerializers);\nvar serializeUint8Array = bindCall(BinaryWriter.prototype.writeUInt8Array);\nvar primitiveDeserializers = {\n  Bool: bindCall(BinaryReader.prototype.readBool),\n  I8: bindCall(BinaryReader.prototype.readI8),\n  U8: bindCall(BinaryReader.prototype.readU8),\n  I16: bindCall(BinaryReader.prototype.readI16),\n  U16: bindCall(BinaryReader.prototype.readU16),\n  I32: bindCall(BinaryReader.prototype.readI32),\n  U32: bindCall(BinaryReader.prototype.readU32),\n  I64: bindCall(BinaryReader.prototype.readI64),\n  U64: bindCall(BinaryReader.prototype.readU64),\n  I128: bindCall(BinaryReader.prototype.readI128),\n  U128: bindCall(BinaryReader.prototype.readU128),\n  I256: bindCall(BinaryReader.prototype.readI256),\n  U256: bindCall(BinaryReader.prototype.readU256),\n  F32: bindCall(BinaryReader.prototype.readF32),\n  F64: bindCall(BinaryReader.prototype.readF64),\n  String: bindCall(BinaryReader.prototype.readString)\n};\nObject.freeze(primitiveDeserializers);\nvar deserializeUint8Array = bindCall(BinaryReader.prototype.readUInt8Array);\nvar primitiveSizes = {\n  Bool: 1,\n  I8: 1,\n  U8: 1,\n  I16: 2,\n  U16: 2,\n  I32: 4,\n  U32: 4,\n  I64: 8,\n  U64: 8,\n  I128: 16,\n  U128: 16,\n  I256: 32,\n  U256: 32,\n  F32: 4,\n  F64: 8\n};\nvar fixedSizePrimitives = new Set(Object.keys(primitiveSizes));\nvar isFixedSizeProduct = (ty) => ty.elements.every(\n  ({ algebraicType }) => fixedSizePrimitives.has(algebraicType.tag)\n);\nvar productSize = (ty) => ty.elements.reduce(\n  (acc, { algebraicType }) => acc + primitiveSizes[algebraicType.tag],\n  0\n);\nvar primitiveJSName = {\n  Bool: \"Uint8\",\n  I8: \"Int8\",\n  U8: \"Uint8\",\n  I16: \"Int16\",\n  U16: \"Uint16\",\n  I32: \"Int32\",\n  U32: \"Uint32\",\n  I64: \"BigInt64\",\n  U64: \"BigUint64\",\n  F32: \"Float32\",\n  F64: \"Float64\"\n};\nvar specialProductDeserializers = {\n  __time_duration_micros__: (reader) => new TimeDuration(reader.readI64()),\n  __timestamp_micros_since_unix_epoch__: (reader) => new Timestamp(reader.readI64()),\n  __identity__: (reader) => new Identity(reader.readU256()),\n  __connection_id__: (reader) => new ConnectionId(reader.readU128()),\n  __uuid__: (reader) => new Uuid(reader.readU128())\n};\nObject.freeze(specialProductDeserializers);\nvar unitDeserializer = () => ({});\nvar getElementInitializer = (element) => {\n  let init;\n  switch (element.algebraicType.tag) {\n    case \"String\":\n      init = \"''\";\n      break;\n    case \"Bool\":\n      init = \"false\";\n      break;\n    case \"I8\":\n    case \"U8\":\n    case \"I16\":\n    case \"U16\":\n    case \"I32\":\n    case \"U32\":\n      init = \"0\";\n      break;\n    case \"I64\":\n    case \"U64\":\n    case \"I128\":\n    case \"U128\":\n    case \"I256\":\n    case \"U256\":\n      init = \"0n\";\n      break;\n    case \"F32\":\n    case \"F64\":\n      init = \"0.0\";\n      break;\n    default:\n      init = \"undefined\";\n  }\n  return `${element.name}: ${init}`;\n};\nvar ProductType = {\n  makeSerializer(ty, typespace) {\n    let serializer = SERIALIZERS.get(ty);\n    if (serializer != null) return serializer;\n    if (isFixedSizeProduct(ty)) {\n      const size = productSize(ty);\n      const body2 = `\"use strict\";\nwriter.expandBuffer(${size});\nconst view = writer.view;\n${ty.elements.map(\n        ({ name, algebraicType: { tag } }) => tag in primitiveJSName ? `view.set${primitiveJSName[tag]}(writer.offset, value.${name}, ${primitiveSizes[tag] > 1 ? \"true\" : \"\"});\nwriter.offset += ${primitiveSizes[tag]};` : `writer.write${tag}(value.${name});`\n      ).join(\"\\n\")}`;\n      serializer = Function(\"writer\", \"value\", body2);\n      SERIALIZERS.set(ty, serializer);\n      return serializer;\n    }\n    const serializers = {};\n    const body = '\"use strict\";\\n' + ty.elements.map(\n      (element) => `this.${element.name}(writer, value.${element.name});`\n    ).join(\"\\n\");\n    serializer = Function(\"writer\", \"value\", body).bind(\n      serializers\n    );\n    SERIALIZERS.set(ty, serializer);\n    for (const { name, algebraicType } of ty.elements) {\n      serializers[name] = AlgebraicType.makeSerializer(\n        algebraicType,\n        typespace\n      );\n    }\n    Object.freeze(serializers);\n    return serializer;\n  },\n  /** @deprecated Use `makeSerializer` instead. */\n  serializeValue(writer, ty, value, typespace) {\n    ProductType.makeSerializer(ty, typespace)(writer, value);\n  },\n  makeDeserializer(ty, typespace) {\n    switch (ty.elements.length) {\n      case 0:\n        return unitDeserializer;\n      case 1: {\n        const fieldName = ty.elements[0].name;\n        if (hasOwn(specialProductDeserializers, fieldName))\n          return specialProductDeserializers[fieldName];\n      }\n    }\n    let deserializer = DESERIALIZERS.get(ty);\n    if (deserializer != null) return deserializer;\n    if (isFixedSizeProduct(ty)) {\n      const body = `\"use strict\";\nconst result = { ${ty.elements.map(getElementInitializer).join(\", \")} };\nconst view = reader.view;\n${ty.elements.map(\n        ({ name, algebraicType: { tag } }) => tag in primitiveJSName ? tag === \"Bool\" ? `result.${name} = view.getUint8(reader.offset) !== 0;\nreader.offset += 1;` : `result.${name} = view.get${primitiveJSName[tag]}(reader.offset, ${primitiveSizes[tag] > 1 ? \"true\" : \"\"});\nreader.offset += ${primitiveSizes[tag]};` : `result.${name} = reader.read${tag}();`\n      ).join(\"\\n\")}\nreturn result;`;\n      deserializer = Function(\"reader\", body);\n      DESERIALIZERS.set(ty, deserializer);\n      return deserializer;\n    }\n    const deserializers = {};\n    deserializer = Function(\n      \"reader\",\n      `\"use strict\";\nconst result = { ${ty.elements.map(getElementInitializer).join(\", \")} };\n${ty.elements.map(({ name }) => `result.${name} = this.${name}(reader);`).join(\"\\n\")}\nreturn result;`\n    ).bind(deserializers);\n    DESERIALIZERS.set(ty, deserializer);\n    for (const { name, algebraicType } of ty.elements) {\n      deserializers[name] = AlgebraicType.makeDeserializer(\n        algebraicType,\n        typespace\n      );\n    }\n    Object.freeze(deserializers);\n    return deserializer;\n  },\n  /** @deprecated Use `makeDeserializer` instead. */\n  deserializeValue(reader, ty, typespace) {\n    return ProductType.makeDeserializer(ty, typespace)(reader);\n  },\n  intoMapKey(ty, value) {\n    if (ty.elements.length === 1) {\n      const fieldName = ty.elements[0].name;\n      if (hasOwn(specialProductDeserializers, fieldName)) {\n        return value[fieldName];\n      }\n    }\n    const writer = new BinaryWriter(10);\n    AlgebraicType.serializeValue(writer, AlgebraicType.Product(ty), value);\n    return writer.toBase64();\n  }\n};\nvar SumType = {\n  makeSerializer(ty, typespace) {\n    if (ty.variants.length == 2 && ty.variants[0].name === \"some\" && ty.variants[1].name === \"none\") {\n      const serialize = AlgebraicType.makeSerializer(\n        ty.variants[0].algebraicType,\n        typespace\n      );\n      return (writer, value) => {\n        if (value !== null && value !== void 0) {\n          writer.writeByte(0);\n          serialize(writer, value);\n        } else {\n          writer.writeByte(1);\n        }\n      };\n    } else if (ty.variants.length == 2 && ty.variants[0].name === \"ok\" && ty.variants[1].name === \"err\") {\n      const serializeOk = AlgebraicType.makeSerializer(\n        ty.variants[0].algebraicType,\n        typespace\n      );\n      const serializeErr = AlgebraicType.makeSerializer(\n        ty.variants[0].algebraicType,\n        typespace\n      );\n      return (writer, value) => {\n        if (\"ok\" in value) {\n          writer.writeU8(0);\n          serializeOk(writer, value.ok);\n        } else if (\"err\" in value) {\n          writer.writeU8(1);\n          serializeErr(writer, value.err);\n        } else {\n          throw new TypeError(\n            \"could not serialize result: object had neither a `ok` nor an `err` field\"\n          );\n        }\n      };\n    } else {\n      let serializer = SERIALIZERS.get(ty);\n      if (serializer != null) return serializer;\n      const serializers = {};\n      const body = `switch (value.tag) {\n${ty.variants.map(\n        ({ name }, i) => `  case ${JSON.stringify(name)}:\n    writer.writeByte(${i});\n    return this.${name}(writer, value.value);`\n      ).join(\"\\n\")}\n  default:\n    throw new TypeError(\n      \\`Could not serialize sum type; unknown tag \\${value.tag}\\`\n    )\n}\n`;\n      serializer = Function(\"writer\", \"value\", body).bind(\n        serializers\n      );\n      SERIALIZERS.set(ty, serializer);\n      for (const { name, algebraicType } of ty.variants) {\n        serializers[name] = AlgebraicType.makeSerializer(\n          algebraicType,\n          typespace\n        );\n      }\n      Object.freeze(serializers);\n      return serializer;\n    }\n  },\n  /** @deprecated Use `makeSerializer` instead. */\n  serializeValue(writer, ty, value, typespace) {\n    SumType.makeSerializer(ty, typespace)(writer, value);\n  },\n  makeDeserializer(ty, typespace) {\n    if (ty.variants.length == 2 && ty.variants[0].name === \"some\" && ty.variants[1].name === \"none\") {\n      const deserialize = AlgebraicType.makeDeserializer(\n        ty.variants[0].algebraicType,\n        typespace\n      );\n      return (reader) => {\n        const tag = reader.readU8();\n        if (tag === 0) {\n          return deserialize(reader);\n        } else if (tag === 1) {\n          return void 0;\n        } else {\n          throw `Can't deserialize an option type, couldn't find ${tag} tag`;\n        }\n      };\n    } else if (ty.variants.length == 2 && ty.variants[0].name === \"ok\" && ty.variants[1].name === \"err\") {\n      const deserializeOk = AlgebraicType.makeDeserializer(\n        ty.variants[0].algebraicType,\n        typespace\n      );\n      const deserializeErr = AlgebraicType.makeDeserializer(\n        ty.variants[1].algebraicType,\n        typespace\n      );\n      return (reader) => {\n        const tag = reader.readByte();\n        if (tag === 0) {\n          return { ok: deserializeOk(reader) };\n        } else if (tag === 1) {\n          return { err: deserializeErr(reader) };\n        } else {\n          throw `Can't deserialize a result type, couldn't find ${tag} tag`;\n        }\n      };\n    } else {\n      let deserializer = DESERIALIZERS.get(ty);\n      if (deserializer != null) return deserializer;\n      const deserializers = {};\n      deserializer = Function(\n        \"reader\",\n        `switch (reader.readU8()) {\n${ty.variants.map(\n          ({ name }, i) => `case ${i}: return { tag: ${JSON.stringify(name)}, value: this.${name}(reader) };`\n        ).join(\"\\n\")} }`\n      ).bind(deserializers);\n      DESERIALIZERS.set(ty, deserializer);\n      for (const { name, algebraicType } of ty.variants) {\n        deserializers[name] = AlgebraicType.makeDeserializer(\n          algebraicType,\n          typespace\n        );\n      }\n      Object.freeze(deserializers);\n      return deserializer;\n    }\n  },\n  /** @deprecated Use `makeDeserializer` instead. */\n  deserializeValue(reader, ty, typespace) {\n    return SumType.makeDeserializer(ty, typespace)(reader);\n  }\n};\n\n// src/lib/option.ts\nvar Option = {\n  getAlgebraicType(innerType) {\n    return AlgebraicType.Sum({\n      variants: [\n        { name: \"some\", algebraicType: innerType },\n        {\n          name: \"none\",\n          algebraicType: AlgebraicType.Product({ elements: [] })\n        }\n      ]\n    });\n  }\n};\n\n// src/lib/result.ts\nvar Result = {\n  getAlgebraicType(okType, errType) {\n    return AlgebraicType.Sum({\n      variants: [\n        { name: \"ok\", algebraicType: okType },\n        { name: \"err\", algebraicType: errType }\n      ]\n    });\n  }\n};\n\n// src/lib/schedule_at.ts\nvar ScheduleAt = {\n  interval(value) {\n    return Interval(value);\n  },\n  time(value) {\n    return Time(value);\n  },\n  getAlgebraicType() {\n    return AlgebraicType.Sum({\n      variants: [\n        {\n          name: \"Interval\",\n          algebraicType: TimeDuration.getAlgebraicType()\n        },\n        { name: \"Time\", algebraicType: Timestamp.getAlgebraicType() }\n      ]\n    });\n  },\n  isScheduleAt(algebraicType) {\n    if (algebraicType.tag !== \"Sum\") {\n      return false;\n    }\n    const variants = algebraicType.value.variants;\n    if (variants.length !== 2) {\n      return false;\n    }\n    const intervalVariant = variants.find((v) => v.name === \"Interval\");\n    const timeVariant = variants.find((v) => v.name === \"Time\");\n    if (!intervalVariant || !timeVariant) {\n      return false;\n    }\n    return TimeDuration.isTimeDuration(intervalVariant.algebraicType) && Timestamp.isTimestamp(timeVariant.algebraicType);\n  }\n};\nvar Interval = (micros) => ({\n  tag: \"Interval\",\n  value: new TimeDuration(micros)\n});\nvar Time = (microsSinceUnixEpoch) => ({\n  tag: \"Time\",\n  value: new Timestamp(microsSinceUnixEpoch)\n});\nvar schedule_at_default = ScheduleAt;\n\n// src/lib/type_util.ts\nfunction set(x, t2) {\n  return { ...x, ...t2 };\n}\n\n// src/lib/type_builders.ts\nvar TypeBuilder = class {\n  /**\n   * The TypeScript phantom type. This is not stored at runtime,\n   * but is visible to the compiler\n   */\n  type;\n  /**\n   * The SpacetimeDB algebraic type (run‑time value). In addition to storing\n   * the runtime representation of the `AlgebraicType`, it also captures\n   * the TypeScript type information of the `AlgebraicType`. That is to say\n   * the value is not merely an `AlgebraicType`, but is constructed to be\n   * the corresponding concrete `AlgebraicType` for the TypeScript type `Type`.\n   *\n   * e.g. `string` corresponds to `AlgebraicType.String`\n   */\n  algebraicType;\n  constructor(algebraicType) {\n    this.algebraicType = algebraicType;\n  }\n  optional() {\n    return new OptionBuilder(this);\n  }\n  serialize(writer, value) {\n    const serialize = this.serialize = AlgebraicType.makeSerializer(\n      this.algebraicType\n    );\n    serialize(writer, value);\n  }\n  deserialize(reader) {\n    const deserialize = this.deserialize = AlgebraicType.makeDeserializer(\n      this.algebraicType\n    );\n    return deserialize(reader);\n  }\n};\nvar U8Builder = class extends TypeBuilder {\n  constructor() {\n    super(AlgebraicType.U8);\n  }\n  index(algorithm = \"btree\") {\n    return new U8ColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new U8ColumnBuilder(this, set(defaultMetadata, { isUnique: true }));\n  }\n  primaryKey() {\n    return new U8ColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new U8ColumnBuilder(\n      this,\n      set(defaultMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new U8ColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new U8ColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar U16Builder = class extends TypeBuilder {\n  constructor() {\n    super(AlgebraicType.U16);\n  }\n  index(algorithm = \"btree\") {\n    return new U16ColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new U16ColumnBuilder(this, set(defaultMetadata, { isUnique: true }));\n  }\n  primaryKey() {\n    return new U16ColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new U16ColumnBuilder(\n      this,\n      set(defaultMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new U16ColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new U16ColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar U32Builder = class extends TypeBuilder {\n  constructor() {\n    super(AlgebraicType.U32);\n  }\n  index(algorithm = \"btree\") {\n    return new U32ColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new U32ColumnBuilder(this, set(defaultMetadata, { isUnique: true }));\n  }\n  primaryKey() {\n    return new U32ColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new U32ColumnBuilder(\n      this,\n      set(defaultMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new U32ColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new U32ColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar U64Builder = class extends TypeBuilder {\n  constructor() {\n    super(AlgebraicType.U64);\n  }\n  index(algorithm = \"btree\") {\n    return new U64ColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new U64ColumnBuilder(this, set(defaultMetadata, { isUnique: true }));\n  }\n  primaryKey() {\n    return new U64ColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new U64ColumnBuilder(\n      this,\n      set(defaultMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new U64ColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new U64ColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar U128Builder = class extends TypeBuilder {\n  constructor() {\n    super(AlgebraicType.U128);\n  }\n  index(algorithm = \"btree\") {\n    return new U128ColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new U128ColumnBuilder(\n      this,\n      set(defaultMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new U128ColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new U128ColumnBuilder(\n      this,\n      set(defaultMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new U128ColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new U128ColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar U256Builder = class extends TypeBuilder {\n  constructor() {\n    super(AlgebraicType.U256);\n  }\n  index(algorithm = \"btree\") {\n    return new U256ColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new U256ColumnBuilder(\n      this,\n      set(defaultMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new U256ColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new U256ColumnBuilder(\n      this,\n      set(defaultMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new U256ColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new U256ColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar I8Builder = class extends TypeBuilder {\n  constructor() {\n    super(AlgebraicType.I8);\n  }\n  index(algorithm = \"btree\") {\n    return new I8ColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new I8ColumnBuilder(this, set(defaultMetadata, { isUnique: true }));\n  }\n  primaryKey() {\n    return new I8ColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new I8ColumnBuilder(\n      this,\n      set(defaultMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new I8ColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new I8ColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar I16Builder = class extends TypeBuilder {\n  constructor() {\n    super(AlgebraicType.I16);\n  }\n  index(algorithm = \"btree\") {\n    return new I16ColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new I16ColumnBuilder(this, set(defaultMetadata, { isUnique: true }));\n  }\n  primaryKey() {\n    return new I16ColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new I16ColumnBuilder(\n      this,\n      set(defaultMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new I16ColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new I16ColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar I32Builder = class extends TypeBuilder {\n  constructor() {\n    super(AlgebraicType.I32);\n  }\n  index(algorithm = \"btree\") {\n    return new I32ColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new I32ColumnBuilder(this, set(defaultMetadata, { isUnique: true }));\n  }\n  primaryKey() {\n    return new I32ColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new I32ColumnBuilder(\n      this,\n      set(defaultMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new I32ColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new I32ColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar I64Builder = class extends TypeBuilder {\n  constructor() {\n    super(AlgebraicType.I64);\n  }\n  index(algorithm = \"btree\") {\n    return new I64ColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new I64ColumnBuilder(this, set(defaultMetadata, { isUnique: true }));\n  }\n  primaryKey() {\n    return new I64ColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new I64ColumnBuilder(\n      this,\n      set(defaultMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new I64ColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new I64ColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar I128Builder = class extends TypeBuilder {\n  constructor() {\n    super(AlgebraicType.I128);\n  }\n  index(algorithm = \"btree\") {\n    return new I128ColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new I128ColumnBuilder(\n      this,\n      set(defaultMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new I128ColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new I128ColumnBuilder(\n      this,\n      set(defaultMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new I128ColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new I128ColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar I256Builder = class extends TypeBuilder {\n  constructor() {\n    super(AlgebraicType.I256);\n  }\n  index(algorithm = \"btree\") {\n    return new I256ColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new I256ColumnBuilder(\n      this,\n      set(defaultMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new I256ColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new I256ColumnBuilder(\n      this,\n      set(defaultMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new I256ColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new I256ColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar F32Builder = class extends TypeBuilder {\n  constructor() {\n    super(AlgebraicType.F32);\n  }\n  default(value) {\n    return new F32ColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new F32ColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar F64Builder = class extends TypeBuilder {\n  constructor() {\n    super(AlgebraicType.F64);\n  }\n  default(value) {\n    return new F64ColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new F64ColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar BoolBuilder = class extends TypeBuilder {\n  constructor() {\n    super(AlgebraicType.Bool);\n  }\n  index(algorithm = \"btree\") {\n    return new BoolColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new BoolColumnBuilder(\n      this,\n      set(defaultMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new BoolColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  default(value) {\n    return new BoolColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new BoolColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar StringBuilder = class extends TypeBuilder {\n  constructor() {\n    super(AlgebraicType.String);\n  }\n  index(algorithm = \"btree\") {\n    return new StringColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new StringColumnBuilder(\n      this,\n      set(defaultMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new StringColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  default(value) {\n    return new StringColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new StringColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar ArrayBuilder = class extends TypeBuilder {\n  element;\n  constructor(element) {\n    super(AlgebraicType.Array(element.algebraicType));\n    this.element = element;\n  }\n  default(value) {\n    return new ArrayColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new ArrayColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar ByteArrayBuilder = class extends TypeBuilder {\n  constructor() {\n    super(AlgebraicType.Array(AlgebraicType.U8));\n  }\n  default(value) {\n    return new ByteArrayColumnBuilder(\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new ByteArrayColumnBuilder(set(defaultMetadata, { name }));\n  }\n};\nvar OptionBuilder = class extends TypeBuilder {\n  value;\n  constructor(value) {\n    super(Option.getAlgebraicType(value.algebraicType));\n    this.value = value;\n  }\n  default(value) {\n    return new OptionColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new OptionColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar ProductBuilder = class extends TypeBuilder {\n  typeName;\n  elements;\n  constructor(elements, name) {\n    function elementsArrayFromElementsObj(obj) {\n      return Object.keys(obj).map((key) => ({\n        name: key,\n        // Lazily resolve the underlying object's algebraicType.\n        // This will call obj[key].algebraicType only when someone\n        // actually reads this property.\n        get algebraicType() {\n          return obj[key].algebraicType;\n        }\n      }));\n    }\n    super(\n      AlgebraicType.Product({\n        elements: elementsArrayFromElementsObj(elements)\n      })\n    );\n    this.typeName = name;\n    this.elements = elements;\n  }\n  default(value) {\n    return new ProductColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new ProductColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar ResultBuilder = class extends TypeBuilder {\n  ok;\n  err;\n  constructor(ok, err) {\n    super(Result.getAlgebraicType(ok.algebraicType, err.algebraicType));\n    this.ok = ok;\n    this.err = err;\n  }\n  default(value) {\n    return new ResultColumnBuilder(this, set(defaultMetadata, { defaultValue: value }));\n  }\n};\nvar UnitBuilder = class extends TypeBuilder {\n  constructor() {\n    super({ tag: \"Product\", value: { elements: [] } });\n  }\n};\nvar RowBuilder = class extends TypeBuilder {\n  row;\n  typeName;\n  constructor(row, name) {\n    const mappedRow = Object.fromEntries(\n      Object.entries(row).map(([colName, builder]) => [\n        colName,\n        builder instanceof ColumnBuilder ? builder : new ColumnBuilder(builder, {})\n      ])\n    );\n    const elements = Object.keys(mappedRow).map((name2) => ({\n      name: name2,\n      get algebraicType() {\n        return mappedRow[name2].typeBuilder.algebraicType;\n      }\n    }));\n    super(AlgebraicType.Product({ elements }));\n    this.row = mappedRow;\n    this.typeName = name;\n  }\n};\nvar SumBuilderImpl = class extends TypeBuilder {\n  variants;\n  typeName;\n  constructor(variants, name) {\n    function variantsArrayFromVariantsObj(variants2) {\n      return Object.keys(variants2).map((key) => ({\n        name: key,\n        // Lazily resolve the underlying object's algebraicType.\n        // This will call obj[key].algebraicType only when someone\n        // actually reads this property.\n        get algebraicType() {\n          return variants2[key].algebraicType;\n        }\n      }));\n    }\n    super(\n      AlgebraicType.Sum({\n        variants: variantsArrayFromVariantsObj(variants)\n      })\n    );\n    this.variants = variants;\n    this.typeName = name;\n    for (const key of Object.keys(variants)) {\n      const desc = Object.getOwnPropertyDescriptor(variants, key);\n      const isAccessor = !!desc && (typeof desc.get === \"function\" || typeof desc.set === \"function\");\n      let isUnit2 = false;\n      if (!isAccessor) {\n        const variant = variants[key];\n        isUnit2 = variant instanceof UnitBuilder;\n      }\n      if (isUnit2) {\n        const constant = this.create(key);\n        Object.defineProperty(this, key, {\n          value: constant,\n          writable: false,\n          enumerable: true,\n          configurable: false\n        });\n      } else {\n        const fn = ((value) => this.create(key, value));\n        Object.defineProperty(this, key, {\n          value: fn,\n          writable: false,\n          enumerable: true,\n          configurable: false\n        });\n      }\n    }\n  }\n  create(tag, value) {\n    return value === void 0 ? { tag } : { tag, value };\n  }\n  default(value) {\n    return new SumColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new SumColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar SumBuilder = SumBuilderImpl;\nvar SimpleSumBuilderImpl = class extends SumBuilderImpl {\n  index(algorithm = \"btree\") {\n    return new SimpleSumColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  primaryKey() {\n    return new SimpleSumColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n};\nvar SimpleSumBuilder = SimpleSumBuilderImpl;\nvar ScheduleAtBuilder = class extends TypeBuilder {\n  constructor() {\n    super(schedule_at_default.getAlgebraicType());\n  }\n  default(value) {\n    return new ScheduleAtColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new ScheduleAtColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar IdentityBuilder = class extends TypeBuilder {\n  constructor() {\n    super(Identity.getAlgebraicType());\n  }\n  index(algorithm = \"btree\") {\n    return new IdentityColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new IdentityColumnBuilder(\n      this,\n      set(defaultMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new IdentityColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new IdentityColumnBuilder(\n      this,\n      set(defaultMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new IdentityColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new IdentityColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar ConnectionIdBuilder = class extends TypeBuilder {\n  constructor() {\n    super(ConnectionId.getAlgebraicType());\n  }\n  index(algorithm = \"btree\") {\n    return new ConnectionIdColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new ConnectionIdColumnBuilder(\n      this,\n      set(defaultMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new ConnectionIdColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new ConnectionIdColumnBuilder(\n      this,\n      set(defaultMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new ConnectionIdColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new ConnectionIdColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar TimestampBuilder = class extends TypeBuilder {\n  constructor() {\n    super(Timestamp.getAlgebraicType());\n  }\n  index(algorithm = \"btree\") {\n    return new TimestampColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new TimestampColumnBuilder(\n      this,\n      set(defaultMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new TimestampColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new TimestampColumnBuilder(\n      this,\n      set(defaultMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new TimestampColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new TimestampColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar TimeDurationBuilder = class extends TypeBuilder {\n  constructor() {\n    super(TimeDuration.getAlgebraicType());\n  }\n  index(algorithm = \"btree\") {\n    return new TimeDurationColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new TimeDurationColumnBuilder(\n      this,\n      set(defaultMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new TimeDurationColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new TimeDurationColumnBuilder(\n      this,\n      set(defaultMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new TimeDurationColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new TimeDurationColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar UuidBuilder = class extends TypeBuilder {\n  constructor() {\n    super(Uuid.getAlgebraicType());\n  }\n  index(algorithm = \"btree\") {\n    return new UuidColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new UuidColumnBuilder(\n      this,\n      set(defaultMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new UuidColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new UuidColumnBuilder(\n      this,\n      set(defaultMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new UuidColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new UuidColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar defaultMetadata = {};\nvar ColumnBuilder = class {\n  typeBuilder;\n  columnMetadata;\n  constructor(typeBuilder, metadata) {\n    this.typeBuilder = typeBuilder;\n    this.columnMetadata = metadata;\n  }\n  serialize(writer, value) {\n    this.typeBuilder.serialize(writer, value);\n  }\n  deserialize(reader) {\n    return this.typeBuilder.deserialize(reader);\n  }\n};\nvar U8ColumnBuilder = class _U8ColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _U8ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _U8ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _U8ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new _U8ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new _U8ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _U8ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar U16ColumnBuilder = class _U16ColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _U16ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _U16ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _U16ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new _U16ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new _U16ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _U16ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar U32ColumnBuilder = class _U32ColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _U32ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _U32ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _U32ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new _U32ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new _U32ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _U32ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar U64ColumnBuilder = class _U64ColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _U64ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _U64ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _U64ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new _U64ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new _U64ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _U64ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar U128ColumnBuilder = class _U128ColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _U128ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _U128ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _U128ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new _U128ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new _U128ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _U128ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar U256ColumnBuilder = class _U256ColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _U256ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _U256ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _U256ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new _U256ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new _U256ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _U256ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar I8ColumnBuilder = class _I8ColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _I8ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _I8ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _I8ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new _I8ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new _I8ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _I8ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar I16ColumnBuilder = class _I16ColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _I16ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _I16ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _I16ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new _I16ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new _I16ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _I16ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar I32ColumnBuilder = class _I32ColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _I32ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _I32ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _I32ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new _I32ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new _I32ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _I32ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar I64ColumnBuilder = class _I64ColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _I64ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _I64ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _I64ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new _I64ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new _I64ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _I64ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar I128ColumnBuilder = class _I128ColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _I128ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _I128ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _I128ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new _I128ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new _I128ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _I128ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar I256ColumnBuilder = class _I256ColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _I256ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _I256ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _I256ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new _I256ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new _I256ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _I256ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar F32ColumnBuilder = class _F32ColumnBuilder extends ColumnBuilder {\n  default(value) {\n    return new _F32ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _F32ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar F64ColumnBuilder = class _F64ColumnBuilder extends ColumnBuilder {\n  default(value) {\n    return new _F64ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _F64ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar BoolColumnBuilder = class _BoolColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _BoolColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _BoolColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _BoolColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  default(value) {\n    return new _BoolColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _BoolColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar StringColumnBuilder = class _StringColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _StringColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _StringColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _StringColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  default(value) {\n    return new _StringColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _StringColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar ArrayColumnBuilder = class _ArrayColumnBuilder extends ColumnBuilder {\n  default(value) {\n    return new _ArrayColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _ArrayColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar ByteArrayColumnBuilder = class _ByteArrayColumnBuilder extends ColumnBuilder {\n  constructor(metadata) {\n    super(new TypeBuilder(AlgebraicType.Array(AlgebraicType.U8)), metadata);\n  }\n  default(value) {\n    return new _ByteArrayColumnBuilder(\n      set(this.columnMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new _ByteArrayColumnBuilder(set(this.columnMetadata, { name }));\n  }\n};\nvar OptionColumnBuilder = class _OptionColumnBuilder extends ColumnBuilder {\n  default(value) {\n    return new _OptionColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _OptionColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar ResultColumnBuilder = class _ResultColumnBuilder extends ColumnBuilder {\n  constructor(typeBuilder, metadata) {\n    super(typeBuilder, metadata);\n  }\n  default(value) {\n    return new _ResultColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n};\nvar ProductColumnBuilder = class _ProductColumnBuilder extends ColumnBuilder {\n  default(value) {\n    return new _ProductColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new _ProductColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar SumColumnBuilder = class _SumColumnBuilder extends ColumnBuilder {\n  default(value) {\n    return new _SumColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new _SumColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar SimpleSumColumnBuilder = class _SimpleSumColumnBuilder extends SumColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _SimpleSumColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  primaryKey() {\n    return new _SimpleSumColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n};\nvar ScheduleAtColumnBuilder = class _ScheduleAtColumnBuilder extends ColumnBuilder {\n  default(value) {\n    return new _ScheduleAtColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new _ScheduleAtColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar IdentityColumnBuilder = class _IdentityColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _IdentityColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _IdentityColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _IdentityColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  default(value) {\n    return new _IdentityColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new _IdentityColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar ConnectionIdColumnBuilder = class _ConnectionIdColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _ConnectionIdColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _ConnectionIdColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _ConnectionIdColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  default(value) {\n    return new _ConnectionIdColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new _ConnectionIdColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar TimestampColumnBuilder = class _TimestampColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _TimestampColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _TimestampColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _TimestampColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  default(value) {\n    return new _TimestampColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new _TimestampColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar TimeDurationColumnBuilder = class _TimeDurationColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _TimeDurationColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _TimeDurationColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _TimeDurationColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  default(value) {\n    return new _TimeDurationColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new _TimeDurationColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar UuidColumnBuilder = class _UuidColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _UuidColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _UuidColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _UuidColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  default(value) {\n    return new _UuidColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new _UuidColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar RefBuilder = class extends TypeBuilder {\n  ref;\n  /** The phantom type of the pointee of this ref. */\n  __spacetimeType;\n  constructor(ref) {\n    super(AlgebraicType.Ref(ref));\n    this.ref = ref;\n  }\n};\nvar enumImpl = ((nameOrObj, maybeObj) => {\n  let obj = nameOrObj;\n  let name = void 0;\n  if (typeof nameOrObj === \"string\") {\n    if (!maybeObj) {\n      throw new TypeError(\n        \"When providing a name, you must also provide the variants object or array.\"\n      );\n    }\n    obj = maybeObj;\n    name = nameOrObj;\n  }\n  if (Array.isArray(obj)) {\n    const simpleVariantsObj = {};\n    for (const variant of obj) {\n      simpleVariantsObj[variant] = new UnitBuilder();\n    }\n    return new SimpleSumBuilderImpl(simpleVariantsObj, name);\n  }\n  return new SumBuilder(obj, name);\n});\nvar t = {\n  /**\n   * Creates a new `Bool` {@link AlgebraicType} to be used in table definitions\n   * Represented as `boolean` in TypeScript.\n   * @returns A new {@link BoolBuilder} instance\n   */\n  bool: () => new BoolBuilder(),\n  /**\n   * Creates a new `String` {@link AlgebraicType} to be used in table definitions\n   * Represented as `string` in TypeScript.\n   * @returns A new {@link StringBuilder} instance\n   */\n  string: () => new StringBuilder(),\n  /**\n   * Creates a new `F64` {@link AlgebraicType} to be used in table definitions\n   * Represented as `number` in TypeScript.\n   * @returns A new {@link F64Builder} instance\n   */\n  number: () => new F64Builder(),\n  /**\n   * Creates a new `I8` {@link AlgebraicType} to be used in table definitions\n   * Represented as `number` in TypeScript.\n   * @returns A new {@link I8Builder} instance\n   */\n  i8: () => new I8Builder(),\n  /**\n   * Creates a new `U8` {@link AlgebraicType} to be used in table definitions\n   * Represented as `number` in TypeScript.\n   * @returns A new {@link U8Builder} instance\n   */\n  u8: () => new U8Builder(),\n  /**\n   * Creates a new `I16` {@link AlgebraicType} to be used in table definitions\n   * Represented as `number` in TypeScript.\n   * @returns A new {@link I16Builder} instance\n   */\n  i16: () => new I16Builder(),\n  /**\n   * Creates a new `U16` {@link AlgebraicType} to be used in table definitions\n   * Represented as `number` in TypeScript.\n   * @returns A new {@link U16Builder} instance\n   */\n  u16: () => new U16Builder(),\n  /**\n   * Creates a new `I32` {@link AlgebraicType} to be used in table definitions\n   * Represented as `number` in TypeScript.\n   * @returns A new {@link I32Builder} instance\n   */\n  i32: () => new I32Builder(),\n  /**\n   * Creates a new `U32` {@link AlgebraicType} to be used in table definitions\n   * Represented as `number` in TypeScript.\n   * @returns A new {@link U32Builder} instance\n   */\n  u32: () => new U32Builder(),\n  /**\n   * Creates a new `I64` {@link AlgebraicType} to be used in table definitions\n   * Represented as `bigint` in TypeScript.\n   * @returns A new {@link I64Builder} instance\n   */\n  i64: () => new I64Builder(),\n  /**\n   * Creates a new `U64` {@link AlgebraicType} to be used in table definitions\n   * Represented as `bigint` in TypeScript.\n   * @returns A new {@link U64Builder} instance\n   */\n  u64: () => new U64Builder(),\n  /**\n   * Creates a new `I128` {@link AlgebraicType} to be used in table definitions\n   * Represented as `bigint` in TypeScript.\n   * @returns A new {@link I128Builder} instance\n   */\n  i128: () => new I128Builder(),\n  /**\n   * Creates a new `U128` {@link AlgebraicType} to be used in table definitions\n   * Represented as `bigint` in TypeScript.\n   * @returns A new {@link U128Builder} instance\n   */\n  u128: () => new U128Builder(),\n  /**\n   * Creates a new `I256` {@link AlgebraicType} to be used in table definitions\n   * Represented as `bigint` in TypeScript.\n   * @returns A new {@link I256Builder} instance\n   */\n  i256: () => new I256Builder(),\n  /**\n   * Creates a new `U256` {@link AlgebraicType} to be used in table definitions\n   * Represented as `bigint` in TypeScript.\n   * @returns A new {@link U256Builder} instance\n   */\n  u256: () => new U256Builder(),\n  /**\n   * Creates a new `F32` {@link AlgebraicType} to be used in table definitions\n   * Represented as `number` in TypeScript.\n   * @returns A new {@link F32Builder} instance\n   */\n  f32: () => new F32Builder(),\n  /**\n   * Creates a new `F64` {@link AlgebraicType} to be used in table definitions\n   * Represented as `number` in TypeScript.\n   * @returns A new {@link F64Builder} instance\n   */\n  f64: () => new F64Builder(),\n  /**\n   * Creates a new `Product` {@link AlgebraicType} to be used in table definitions. Product types in SpacetimeDB\n   * are essentially the same as objects in JavaScript/TypeScript.\n   * Properties of the object must also be {@link TypeBuilder}s.\n   * Represented as an object with specific properties in TypeScript.\n   *\n   * @param name (optional) A display name for the product type. If omitted, an anonymous product type is created.\n   * @param obj The object defining the properties of the type, whose property\n   * values must be {@link TypeBuilder}s.\n   * @returns A new {@link ProductBuilder} instance.\n   */\n  object: ((nameOrObj, maybeObj) => {\n    if (typeof nameOrObj === \"string\") {\n      if (!maybeObj) {\n        throw new TypeError(\n          \"When providing a name, you must also provide the object.\"\n        );\n      }\n      return new ProductBuilder(maybeObj, nameOrObj);\n    }\n    return new ProductBuilder(nameOrObj, void 0);\n  }),\n  /**\n   * Creates a new `Row` {@link AlgebraicType} to be used in table definitions. Row types in SpacetimeDB\n   * are similar to `Product` types, but are specifically used to define the schema of a table row.\n   * Properties of the object must also be {@link TypeBuilder} or {@link ColumnBuilder}s.\n   *\n   * You can represent a `Row` as either a {@link RowObj} or an {@link RowBuilder} type when\n   * defining a table schema.\n   *\n   * The {@link RowBuilder} type is useful when you want to create a type which can be used anywhere\n   * a {@link TypeBuilder} is accepted, such as in nested objects or arrays, or as the argument\n   * to a scheduled function.\n   *\n   * @param obj The object defining the properties of the row, whose property\n   * values must be {@link TypeBuilder}s or {@link ColumnBuilder}s.\n   * @returns A new {@link RowBuilder} instance\n   */\n  row: ((nameOrObj, maybeObj) => {\n    const [obj, name] = typeof nameOrObj === \"string\" ? [maybeObj, nameOrObj] : [nameOrObj, void 0];\n    return new RowBuilder(obj, name);\n  }),\n  /**\n   * Creates a new `Array` {@link AlgebraicType} to be used in table definitions.\n   * Represented as an array in TypeScript.\n   * @param element The element type of the array, which must be a `TypeBuilder`.\n   * @returns A new {@link ArrayBuilder} instance\n   */\n  array(e) {\n    return new ArrayBuilder(e);\n  },\n  enum: enumImpl,\n  /**\n   * This is a special helper function for conveniently creating `Product` type columns with no fields.\n   *\n   * @returns A new {@link ProductBuilder} instance with no fields.\n   */\n  unit() {\n    return new UnitBuilder();\n  },\n  /**\n   * Creates a lazily-evaluated {@link TypeBuilder}. This is useful for creating\n   * recursive types, such as a tree or linked list.\n   * @param thunk A function that returns a {@link TypeBuilder}.\n   * @returns A proxy {@link TypeBuilder} that evaluates the thunk on first access.\n   */\n  lazy(thunk) {\n    let cached = null;\n    const get = () => cached ??= thunk();\n    const proxy = new Proxy({}, {\n      get(_t, prop, recv) {\n        const target = get();\n        const val = Reflect.get(target, prop, recv);\n        return typeof val === \"function\" ? val.bind(target) : val;\n      },\n      set(_t, prop, value, recv) {\n        return Reflect.set(get(), prop, value, recv);\n      },\n      has(_t, prop) {\n        return prop in get();\n      },\n      ownKeys() {\n        return Reflect.ownKeys(get());\n      },\n      getOwnPropertyDescriptor(_t, prop) {\n        return Object.getOwnPropertyDescriptor(get(), prop);\n      },\n      getPrototypeOf() {\n        return Object.getPrototypeOf(get());\n      }\n    });\n    return proxy;\n  },\n  /**\n   * This is a special helper function for conveniently creating {@link ScheduleAt} type columns.\n   * @returns A new ColumnBuilder instance with the {@link ScheduleAt} type.\n   */\n  scheduleAt: () => {\n    return new ScheduleAtBuilder();\n  },\n  /**\n   * This is a convenience method for creating a column with the {@link Option} type.\n   * You can create a column of the same type by constructing an enum with a `some` and `none` variant.\n   * @param value The type of the value contained in the `some` variant of the `Option`.\n   * @returns A new {@link OptionBuilder} instance with the {@link Option} type.\n   */\n  option(value) {\n    return new OptionBuilder(value);\n  },\n  /**\n   * This is a convenience method for creating a column with the {@link Result} type.\n   * You can create a column of the same type by constructing an enum with an `ok` and `err` variant.\n   * @param ok The type of the value contained in the `ok` variant of the `Result`.\n   * @param err The type of the value contained in the `err` variant of the `Result`.\n   * @returns A new {@link ResultBuilder} instance with the {@link Result} type.\n   */\n  result(ok, err) {\n    return new ResultBuilder(ok, err);\n  },\n  /**\n   * This is a convenience method for creating a column with the {@link Identity} type.\n   * You can create a column of the same type by constructing an `object` with a single `__identity__` element.\n   * @returns A new {@link TypeBuilder} instance with the {@link Identity} type.\n   */\n  identity: () => {\n    return new IdentityBuilder();\n  },\n  /**\n   * This is a convenience method for creating a column with the {@link ConnectionId} type.\n   * You can create a column of the same type by constructing an `object` with a single `__connection_id__` element.\n   * @returns A new {@link TypeBuilder} instance with the {@link ConnectionId} type.\n   */\n  connectionId: () => {\n    return new ConnectionIdBuilder();\n  },\n  /**\n   * This is a convenience method for creating a column with the {@link Timestamp} type.\n   * You can create a column of the same type by constructing an `object` with a single `__timestamp_micros_since_unix_epoch__` element.\n   * @returns A new {@link TypeBuilder} instance with the {@link Timestamp} type.\n   */\n  timestamp: () => {\n    return new TimestampBuilder();\n  },\n  /**\n   * This is a convenience method for creating a column with the {@link TimeDuration} type.\n   * You can create a column of the same type by constructing an `object` with a single `__time_duration_micros__` element.\n   * @returns A new {@link TypeBuilder} instance with the {@link TimeDuration} type.\n   */\n  timeDuration: () => {\n    return new TimeDurationBuilder();\n  },\n  /**\n   * This is a convenience method for creating a column with the {@link Uuid} type.\n   * You can create a column of the same type by constructing an `object` with a single `__uuid__` element.\n   * @returns A new {@link TypeBuilder} instance with the {@link Uuid} type.\n   */\n  uuid: () => {\n    return new UuidBuilder();\n  },\n  /**\n   * This is a convenience method for creating a column with the `ByteArray` type.\n   * You can create a column of the same type by constructing an `array` of `u8`.\n   * The TypeScript representation is {@link Uint8Array}.\n   * @returns A new {@link ByteArrayBuilder} instance with the `ByteArray` type.\n   */\n  byteArray: () => {\n    return new ByteArrayBuilder();\n  }\n};\n\n// src/lib/autogen/types.ts\nvar AlgebraicType2 = t.enum(\"AlgebraicType\", {\n  Ref: t.u32(),\n  get Sum() {\n    return SumType2;\n  },\n  get Product() {\n    return ProductType2;\n  },\n  get Array() {\n    return AlgebraicType2;\n  },\n  String: t.unit(),\n  Bool: t.unit(),\n  I8: t.unit(),\n  U8: t.unit(),\n  I16: t.unit(),\n  U16: t.unit(),\n  I32: t.unit(),\n  U32: t.unit(),\n  I64: t.unit(),\n  U64: t.unit(),\n  I128: t.unit(),\n  U128: t.unit(),\n  I256: t.unit(),\n  U256: t.unit(),\n  F32: t.unit(),\n  F64: t.unit()\n});\nvar CaseConversionPolicy = t.enum(\"CaseConversionPolicy\", {\n  None: t.unit(),\n  SnakeCase: t.unit()\n});\nvar ExplicitNameEntry = t.enum(\"ExplicitNameEntry\", {\n  get Table() {\n    return NameMapping;\n  },\n  get Function() {\n    return NameMapping;\n  },\n  get Index() {\n    return NameMapping;\n  }\n});\nvar ExplicitNames = t.object(\"ExplicitNames\", {\n  get entries() {\n    return t.array(ExplicitNameEntry);\n  }\n});\nvar FunctionVisibility = t.enum(\"FunctionVisibility\", {\n  Private: t.unit(),\n  ClientCallable: t.unit()\n});\nvar HttpHeaderPair = t.object(\"HttpHeaderPair\", {\n  name: t.string(),\n  value: t.byteArray()\n});\nvar HttpHeaders = t.object(\"HttpHeaders\", {\n  get entries() {\n    return t.array(HttpHeaderPair);\n  }\n});\nvar HttpMethod = t.enum(\"HttpMethod\", {\n  Get: t.unit(),\n  Head: t.unit(),\n  Post: t.unit(),\n  Put: t.unit(),\n  Delete: t.unit(),\n  Connect: t.unit(),\n  Options: t.unit(),\n  Trace: t.unit(),\n  Patch: t.unit(),\n  Extension: t.string()\n});\nvar HttpRequest = t.object(\"HttpRequest\", {\n  get method() {\n    return HttpMethod;\n  },\n  get headers() {\n    return HttpHeaders;\n  },\n  timeout: t.option(t.timeDuration()),\n  uri: t.string(),\n  get version() {\n    return HttpVersion;\n  }\n});\nvar HttpResponse = t.object(\"HttpResponse\", {\n  get headers() {\n    return HttpHeaders;\n  },\n  get version() {\n    return HttpVersion;\n  },\n  code: t.u16()\n});\nvar HttpVersion = t.enum(\"HttpVersion\", {\n  Http09: t.unit(),\n  Http10: t.unit(),\n  Http11: t.unit(),\n  Http2: t.unit(),\n  Http3: t.unit()\n});\nvar IndexType = t.enum(\"IndexType\", {\n  BTree: t.unit(),\n  Hash: t.unit()\n});\nvar Lifecycle = t.enum(\"Lifecycle\", {\n  Init: t.unit(),\n  OnConnect: t.unit(),\n  OnDisconnect: t.unit()\n});\nvar MiscModuleExport = t.enum(\"MiscModuleExport\", {\n  get TypeAlias() {\n    return TypeAlias;\n  }\n});\nvar NameMapping = t.object(\"NameMapping\", {\n  sourceName: t.string(),\n  canonicalName: t.string()\n});\nvar ProductType2 = t.object(\"ProductType\", {\n  get elements() {\n    return t.array(ProductTypeElement);\n  }\n});\nvar ProductTypeElement = t.object(\"ProductTypeElement\", {\n  name: t.option(t.string()),\n  get algebraicType() {\n    return AlgebraicType2;\n  }\n});\nvar RawColumnDefV8 = t.object(\"RawColumnDefV8\", {\n  colName: t.string(),\n  get colType() {\n    return AlgebraicType2;\n  }\n});\nvar RawColumnDefaultValueV10 = t.object(\"RawColumnDefaultValueV10\", {\n  colId: t.u16(),\n  value: t.byteArray()\n});\nvar RawColumnDefaultValueV9 = t.object(\"RawColumnDefaultValueV9\", {\n  table: t.string(),\n  colId: t.u16(),\n  value: t.byteArray()\n});\nvar RawConstraintDataV9 = t.enum(\"RawConstraintDataV9\", {\n  get Unique() {\n    return RawUniqueConstraintDataV9;\n  }\n});\nvar RawConstraintDefV10 = t.object(\"RawConstraintDefV10\", {\n  sourceName: t.option(t.string()),\n  get data() {\n    return RawConstraintDataV9;\n  }\n});\nvar RawConstraintDefV8 = t.object(\"RawConstraintDefV8\", {\n  constraintName: t.string(),\n  constraints: t.u8(),\n  columns: t.array(t.u16())\n});\nvar RawConstraintDefV9 = t.object(\"RawConstraintDefV9\", {\n  name: t.option(t.string()),\n  get data() {\n    return RawConstraintDataV9;\n  }\n});\nvar RawIndexAlgorithm = t.enum(\"RawIndexAlgorithm\", {\n  BTree: t.array(t.u16()),\n  Hash: t.array(t.u16()),\n  Direct: t.u16()\n});\nvar RawIndexDefV10 = t.object(\"RawIndexDefV10\", {\n  sourceName: t.option(t.string()),\n  accessorName: t.option(t.string()),\n  get algorithm() {\n    return RawIndexAlgorithm;\n  }\n});\nvar RawIndexDefV8 = t.object(\"RawIndexDefV8\", {\n  indexName: t.string(),\n  isUnique: t.bool(),\n  get indexType() {\n    return IndexType;\n  },\n  columns: t.array(t.u16())\n});\nvar RawIndexDefV9 = t.object(\"RawIndexDefV9\", {\n  name: t.option(t.string()),\n  accessorName: t.option(t.string()),\n  get algorithm() {\n    return RawIndexAlgorithm;\n  }\n});\nvar RawLifeCycleReducerDefV10 = t.object(\n  \"RawLifeCycleReducerDefV10\",\n  {\n    get lifecycleSpec() {\n      return Lifecycle;\n    },\n    functionName: t.string()\n  }\n);\nvar RawMiscModuleExportV9 = t.enum(\"RawMiscModuleExportV9\", {\n  get ColumnDefaultValue() {\n    return RawColumnDefaultValueV9;\n  },\n  get Procedure() {\n    return RawProcedureDefV9;\n  },\n  get View() {\n    return RawViewDefV9;\n  }\n});\nvar RawModuleDef = t.enum(\"RawModuleDef\", {\n  get V8BackCompat() {\n    return RawModuleDefV8;\n  },\n  get V9() {\n    return RawModuleDefV9;\n  },\n  get V10() {\n    return RawModuleDefV10;\n  }\n});\nvar RawModuleDefV10 = t.object(\"RawModuleDefV10\", {\n  get sections() {\n    return t.array(RawModuleDefV10Section);\n  }\n});\nvar RawModuleDefV10Section = t.enum(\"RawModuleDefV10Section\", {\n  get Typespace() {\n    return Typespace;\n  },\n  get Types() {\n    return t.array(RawTypeDefV10);\n  },\n  get Tables() {\n    return t.array(RawTableDefV10);\n  },\n  get Reducers() {\n    return t.array(RawReducerDefV10);\n  },\n  get Procedures() {\n    return t.array(RawProcedureDefV10);\n  },\n  get Views() {\n    return t.array(RawViewDefV10);\n  },\n  get Schedules() {\n    return t.array(RawScheduleDefV10);\n  },\n  get LifeCycleReducers() {\n    return t.array(RawLifeCycleReducerDefV10);\n  },\n  get RowLevelSecurity() {\n    return t.array(RawRowLevelSecurityDefV9);\n  },\n  get CaseConversionPolicy() {\n    return CaseConversionPolicy;\n  },\n  get ExplicitNames() {\n    return ExplicitNames;\n  }\n});\nvar RawModuleDefV8 = t.object(\"RawModuleDefV8\", {\n  get typespace() {\n    return Typespace;\n  },\n  get tables() {\n    return t.array(TableDesc);\n  },\n  get reducers() {\n    return t.array(ReducerDef);\n  },\n  get miscExports() {\n    return t.array(MiscModuleExport);\n  }\n});\nvar RawModuleDefV9 = t.object(\"RawModuleDefV9\", {\n  get typespace() {\n    return Typespace;\n  },\n  get tables() {\n    return t.array(RawTableDefV9);\n  },\n  get reducers() {\n    return t.array(RawReducerDefV9);\n  },\n  get types() {\n    return t.array(RawTypeDefV9);\n  },\n  get miscExports() {\n    return t.array(RawMiscModuleExportV9);\n  },\n  get rowLevelSecurity() {\n    return t.array(RawRowLevelSecurityDefV9);\n  }\n});\nvar RawProcedureDefV10 = t.object(\"RawProcedureDefV10\", {\n  sourceName: t.string(),\n  get params() {\n    return ProductType2;\n  },\n  get returnType() {\n    return AlgebraicType2;\n  },\n  get visibility() {\n    return FunctionVisibility;\n  }\n});\nvar RawProcedureDefV9 = t.object(\"RawProcedureDefV9\", {\n  name: t.string(),\n  get params() {\n    return ProductType2;\n  },\n  get returnType() {\n    return AlgebraicType2;\n  }\n});\nvar RawReducerDefV10 = t.object(\"RawReducerDefV10\", {\n  sourceName: t.string(),\n  get params() {\n    return ProductType2;\n  },\n  get visibility() {\n    return FunctionVisibility;\n  },\n  get okReturnType() {\n    return AlgebraicType2;\n  },\n  get errReturnType() {\n    return AlgebraicType2;\n  }\n});\nvar RawReducerDefV9 = t.object(\"RawReducerDefV9\", {\n  name: t.string(),\n  get params() {\n    return ProductType2;\n  },\n  get lifecycle() {\n    return t.option(Lifecycle);\n  }\n});\nvar RawRowLevelSecurityDefV9 = t.object(\"RawRowLevelSecurityDefV9\", {\n  sql: t.string()\n});\nvar RawScheduleDefV10 = t.object(\"RawScheduleDefV10\", {\n  sourceName: t.option(t.string()),\n  tableName: t.string(),\n  scheduleAtCol: t.u16(),\n  functionName: t.string()\n});\nvar RawScheduleDefV9 = t.object(\"RawScheduleDefV9\", {\n  name: t.option(t.string()),\n  reducerName: t.string(),\n  scheduledAtColumn: t.u16()\n});\nvar RawScopedTypeNameV10 = t.object(\"RawScopedTypeNameV10\", {\n  scope: t.array(t.string()),\n  sourceName: t.string()\n});\nvar RawScopedTypeNameV9 = t.object(\"RawScopedTypeNameV9\", {\n  scope: t.array(t.string()),\n  name: t.string()\n});\nvar RawSequenceDefV10 = t.object(\"RawSequenceDefV10\", {\n  sourceName: t.option(t.string()),\n  column: t.u16(),\n  start: t.option(t.i128()),\n  minValue: t.option(t.i128()),\n  maxValue: t.option(t.i128()),\n  increment: t.i128()\n});\nvar RawSequenceDefV8 = t.object(\"RawSequenceDefV8\", {\n  sequenceName: t.string(),\n  colPos: t.u16(),\n  increment: t.i128(),\n  start: t.option(t.i128()),\n  minValue: t.option(t.i128()),\n  maxValue: t.option(t.i128()),\n  allocated: t.i128()\n});\nvar RawSequenceDefV9 = t.object(\"RawSequenceDefV9\", {\n  name: t.option(t.string()),\n  column: t.u16(),\n  start: t.option(t.i128()),\n  minValue: t.option(t.i128()),\n  maxValue: t.option(t.i128()),\n  increment: t.i128()\n});\nvar RawTableDefV10 = t.object(\"RawTableDefV10\", {\n  sourceName: t.string(),\n  productTypeRef: t.u32(),\n  primaryKey: t.array(t.u16()),\n  get indexes() {\n    return t.array(RawIndexDefV10);\n  },\n  get constraints() {\n    return t.array(RawConstraintDefV10);\n  },\n  get sequences() {\n    return t.array(RawSequenceDefV10);\n  },\n  get tableType() {\n    return TableType;\n  },\n  get tableAccess() {\n    return TableAccess;\n  },\n  get defaultValues() {\n    return t.array(RawColumnDefaultValueV10);\n  },\n  isEvent: t.bool()\n});\nvar RawTableDefV8 = t.object(\"RawTableDefV8\", {\n  tableName: t.string(),\n  get columns() {\n    return t.array(RawColumnDefV8);\n  },\n  get indexes() {\n    return t.array(RawIndexDefV8);\n  },\n  get constraints() {\n    return t.array(RawConstraintDefV8);\n  },\n  get sequences() {\n    return t.array(RawSequenceDefV8);\n  },\n  tableType: t.string(),\n  tableAccess: t.string(),\n  scheduled: t.option(t.string())\n});\nvar RawTableDefV9 = t.object(\"RawTableDefV9\", {\n  name: t.string(),\n  productTypeRef: t.u32(),\n  primaryKey: t.array(t.u16()),\n  get indexes() {\n    return t.array(RawIndexDefV9);\n  },\n  get constraints() {\n    return t.array(RawConstraintDefV9);\n  },\n  get sequences() {\n    return t.array(RawSequenceDefV9);\n  },\n  get schedule() {\n    return t.option(RawScheduleDefV9);\n  },\n  get tableType() {\n    return TableType;\n  },\n  get tableAccess() {\n    return TableAccess;\n  }\n});\nvar RawTypeDefV10 = t.object(\"RawTypeDefV10\", {\n  get sourceName() {\n    return RawScopedTypeNameV10;\n  },\n  ty: t.u32(),\n  customOrdering: t.bool()\n});\nvar RawTypeDefV9 = t.object(\"RawTypeDefV9\", {\n  get name() {\n    return RawScopedTypeNameV9;\n  },\n  ty: t.u32(),\n  customOrdering: t.bool()\n});\nvar RawUniqueConstraintDataV9 = t.object(\n  \"RawUniqueConstraintDataV9\",\n  {\n    columns: t.array(t.u16())\n  }\n);\nvar RawViewDefV10 = t.object(\"RawViewDefV10\", {\n  sourceName: t.string(),\n  index: t.u32(),\n  isPublic: t.bool(),\n  isAnonymous: t.bool(),\n  get params() {\n    return ProductType2;\n  },\n  get returnType() {\n    return AlgebraicType2;\n  }\n});\nvar RawViewDefV9 = t.object(\"RawViewDefV9\", {\n  name: t.string(),\n  index: t.u32(),\n  isPublic: t.bool(),\n  isAnonymous: t.bool(),\n  get params() {\n    return ProductType2;\n  },\n  get returnType() {\n    return AlgebraicType2;\n  }\n});\nvar ReducerDef = t.object(\"ReducerDef\", {\n  name: t.string(),\n  get args() {\n    return t.array(ProductTypeElement);\n  }\n});\nvar SumType2 = t.object(\"SumType\", {\n  get variants() {\n    return t.array(SumTypeVariant);\n  }\n});\nvar SumTypeVariant = t.object(\"SumTypeVariant\", {\n  name: t.option(t.string()),\n  get algebraicType() {\n    return AlgebraicType2;\n  }\n});\nvar TableAccess = t.enum(\"TableAccess\", {\n  Public: t.unit(),\n  Private: t.unit()\n});\nvar TableDesc = t.object(\"TableDesc\", {\n  get schema() {\n    return RawTableDefV8;\n  },\n  data: t.u32()\n});\nvar TableType = t.enum(\"TableType\", {\n  System: t.unit(),\n  User: t.unit()\n});\nvar TypeAlias = t.object(\"TypeAlias\", {\n  name: t.string(),\n  ty: t.u32()\n});\nvar Typespace = t.object(\"Typespace\", {\n  get types() {\n    return t.array(AlgebraicType2);\n  }\n});\nvar ViewResultHeader = t.enum(\"ViewResultHeader\", {\n  RowData: t.unit(),\n  RawSql: t.string()\n});\n\n// src/lib/schema.ts\nfunction tableToSchema(accName, schema2, tableDef) {\n  const getColName = (i) => schema2.rowType.algebraicType.value.elements[i].name;\n  const resolvedIndexes = tableDef.indexes.map(\n    (idx) => {\n      const accessorName = idx.accessorName;\n      if (typeof accessorName !== \"string\" || accessorName.length === 0) {\n        throw new TypeError(\n          `Index '${idx.sourceName ?? \"<unknown>\"}' on table '${tableDef.sourceName}' is missing accessor name`\n        );\n      }\n      const columnIds = idx.algorithm.tag === \"Direct\" ? [idx.algorithm.value] : idx.algorithm.value;\n      const unique = tableDef.constraints.some(\n        (c) => c.data.tag === \"Unique\" && c.data.value.columns.every((col) => columnIds.includes(col))\n      );\n      const algorithm = {\n        BTree: \"btree\",\n        Hash: \"hash\",\n        Direct: \"direct\"\n      }[idx.algorithm.tag];\n      return {\n        name: accessorName,\n        unique,\n        algorithm,\n        columns: columnIds.map(getColName)\n      };\n    }\n  );\n  return {\n    // For client,`schama.tableName` will always be there as canonical name.\n    // For module, if explicit name is not provided via `name`, accessor name will\n    // be used, it is stored as alias in database, hence works in query builder.\n    sourceName: schema2.tableName || accName,\n    accessorName: accName,\n    columns: schema2.rowType.row,\n    // typed as T[i]['rowType']['row'] under TablesToSchema<T>\n    rowType: schema2.rowSpacetimeType,\n    // Keep declarative indexes in their original shape for type-level consumers.\n    indexes: schema2.idxs,\n    constraints: tableDef.constraints.map((c) => ({\n      name: c.sourceName,\n      constraint: \"unique\",\n      columns: c.data.value.columns.map(getColName)\n    })),\n    // Expose resolved runtime indexes separately so runtime users don't have to\n    // reinterpret `indexes` with unsafe casts.\n    resolvedIndexes,\n    tableDef,\n    ...tableDef.isEvent ? { isEvent: true } : {}\n  };\n}\nvar ModuleContext = class {\n  #compoundTypes = /* @__PURE__ */ new Map();\n  /**\n   * The global module definition that gets populated by calls to `reducer()` and lifecycle hooks.\n   */\n  #moduleDef = {\n    typespace: { types: [] },\n    tables: [],\n    reducers: [],\n    types: [],\n    rowLevelSecurity: [],\n    schedules: [],\n    procedures: [],\n    views: [],\n    lifeCycleReducers: [],\n    caseConversionPolicy: { tag: \"SnakeCase\" },\n    explicitNames: {\n      entries: []\n    }\n  };\n  get moduleDef() {\n    return this.#moduleDef;\n  }\n  rawModuleDefV10() {\n    const sections = [];\n    const push = (s) => {\n      if (s) sections.push(s);\n    };\n    const module = this.#moduleDef;\n    push(module.typespace && { tag: \"Typespace\", value: module.typespace });\n    push(module.types && { tag: \"Types\", value: module.types });\n    push(module.tables && { tag: \"Tables\", value: module.tables });\n    push(module.reducers && { tag: \"Reducers\", value: module.reducers });\n    push(module.procedures && { tag: \"Procedures\", value: module.procedures });\n    push(module.views && { tag: \"Views\", value: module.views });\n    push(module.schedules && { tag: \"Schedules\", value: module.schedules });\n    push(\n      module.lifeCycleReducers && {\n        tag: \"LifeCycleReducers\",\n        value: module.lifeCycleReducers\n      }\n    );\n    push(\n      module.rowLevelSecurity && {\n        tag: \"RowLevelSecurity\",\n        value: module.rowLevelSecurity\n      }\n    );\n    push(\n      module.explicitNames && {\n        tag: \"ExplicitNames\",\n        value: module.explicitNames\n      }\n    );\n    push(\n      module.caseConversionPolicy && {\n        tag: \"CaseConversionPolicy\",\n        value: module.caseConversionPolicy\n      }\n    );\n    return { sections };\n  }\n  /**\n   * Set the case conversion policy for this module.\n   * Called by the settings mechanism.\n   */\n  setCaseConversionPolicy(policy) {\n    this.#moduleDef.caseConversionPolicy = policy;\n  }\n  get typespace() {\n    return this.#moduleDef.typespace;\n  }\n  /**\n   * Resolves the actual type of a TypeBuilder by following its references until it reaches a non-ref type.\n   * @param typespace The typespace to resolve types against.\n   * @param typeBuilder The TypeBuilder to resolve.\n   * @returns The resolved algebraic type.\n   */\n  resolveType(typeBuilder) {\n    let ty = typeBuilder.algebraicType;\n    while (ty.tag === \"Ref\") {\n      ty = this.typespace.types[ty.value];\n    }\n    return ty;\n  }\n  /**\n   * Adds a type to the module definition's typespace as a `Ref` if it is a named compound type (Product or Sum).\n   * Otherwise, returns the type as is.\n   * @param name\n   * @param ty\n   * @returns\n   */\n  registerTypesRecursively(typeBuilder) {\n    if (typeBuilder instanceof ProductBuilder && !isUnit(typeBuilder) || typeBuilder instanceof SumBuilder || typeBuilder instanceof RowBuilder) {\n      return this.#registerCompoundTypeRecursively(typeBuilder);\n    } else if (typeBuilder instanceof OptionBuilder) {\n      return new OptionBuilder(\n        this.registerTypesRecursively(typeBuilder.value)\n      );\n    } else if (typeBuilder instanceof ResultBuilder) {\n      return new ResultBuilder(\n        this.registerTypesRecursively(typeBuilder.ok),\n        this.registerTypesRecursively(typeBuilder.err)\n      );\n    } else if (typeBuilder instanceof ArrayBuilder) {\n      return new ArrayBuilder(\n        this.registerTypesRecursively(typeBuilder.element)\n      );\n    } else {\n      return typeBuilder;\n    }\n  }\n  #registerCompoundTypeRecursively(typeBuilder) {\n    const ty = typeBuilder.algebraicType;\n    const name = typeBuilder.typeName;\n    if (name === void 0) {\n      throw new Error(\n        `Missing type name for ${typeBuilder.constructor.name ?? \"TypeBuilder\"} ${JSON.stringify(typeBuilder)}`\n      );\n    }\n    let r = this.#compoundTypes.get(ty);\n    if (r != null) {\n      return r;\n    }\n    const newTy = typeBuilder instanceof RowBuilder || typeBuilder instanceof ProductBuilder ? {\n      tag: \"Product\",\n      value: { elements: [] }\n    } : {\n      tag: \"Sum\",\n      value: { variants: [] }\n    };\n    r = new RefBuilder(this.#moduleDef.typespace.types.length);\n    this.#moduleDef.typespace.types.push(newTy);\n    this.#compoundTypes.set(ty, r);\n    if (typeBuilder instanceof RowBuilder) {\n      for (const [name2, elem] of Object.entries(typeBuilder.row)) {\n        newTy.value.elements.push({\n          name: name2,\n          algebraicType: this.registerTypesRecursively(elem.typeBuilder).algebraicType\n        });\n      }\n    } else if (typeBuilder instanceof ProductBuilder) {\n      for (const [name2, elem] of Object.entries(typeBuilder.elements)) {\n        newTy.value.elements.push({\n          name: name2,\n          algebraicType: this.registerTypesRecursively(elem).algebraicType\n        });\n      }\n    } else if (typeBuilder instanceof SumBuilder) {\n      for (const [name2, variant] of Object.entries(typeBuilder.variants)) {\n        newTy.value.variants.push({\n          name: name2,\n          algebraicType: this.registerTypesRecursively(variant).algebraicType\n        });\n      }\n    }\n    this.#moduleDef.types.push({\n      sourceName: splitName(name),\n      ty: r.ref,\n      customOrdering: true\n    });\n    return r;\n  }\n};\nfunction isUnit(typeBuilder) {\n  return typeBuilder.typeName == null && typeBuilder.algebraicType.value.elements.length === 0;\n}\nfunction splitName(name) {\n  const scope = name.split(\".\");\n  return { sourceName: scope.pop(), scope };\n}\n\n// src/server/http_internal.ts\nvar import_statuses = __toESM(require_statuses());\n\n// src/server/range.ts\nvar Range = class {\n  #from;\n  #to;\n  constructor(from, to) {\n    this.#from = from ?? { tag: \"unbounded\" };\n    this.#to = to ?? { tag: \"unbounded\" };\n  }\n  get from() {\n    return this.#from;\n  }\n  get to() {\n    return this.#to;\n  }\n};\n\n// src/lib/table.ts\nfunction table(opts, row, ..._) {\n  const {\n    name,\n    public: isPublic = false,\n    indexes: userIndexes = [],\n    scheduled,\n    event: isEvent = false\n  } = opts;\n  const colIds = /* @__PURE__ */ new Map();\n  const colNameList = [];\n  if (!(row instanceof RowBuilder)) {\n    row = new RowBuilder(row);\n  }\n  row.algebraicType.value.elements.forEach((elem, i) => {\n    colIds.set(elem.name, i);\n    colNameList.push(elem.name);\n  });\n  const pk = [];\n  const indexes = [];\n  const constraints = [];\n  const sequences = [];\n  let scheduleAtCol;\n  const defaultValues = [];\n  for (const [name2, builder] of Object.entries(row.row)) {\n    const meta = builder.columnMetadata;\n    if (meta.isPrimaryKey) {\n      pk.push(colIds.get(name2));\n    }\n    const isUnique = meta.isUnique || meta.isPrimaryKey;\n    if (meta.indexType || isUnique) {\n      const algo = meta.indexType ?? \"btree\";\n      const id = colIds.get(name2);\n      let algorithm;\n      switch (algo) {\n        case \"btree\":\n          algorithm = RawIndexAlgorithm.BTree([id]);\n          break;\n        case \"hash\":\n          algorithm = RawIndexAlgorithm.Hash([id]);\n          break;\n        case \"direct\":\n          algorithm = RawIndexAlgorithm.Direct(id);\n          break;\n      }\n      indexes.push({\n        sourceName: void 0,\n        // Unnamed indexes will be assigned a globally unique name\n        accessorName: name2,\n        algorithm\n      });\n    }\n    if (isUnique) {\n      constraints.push({\n        sourceName: void 0,\n        data: { tag: \"Unique\", value: { columns: [colIds.get(name2)] } }\n      });\n    }\n    if (meta.isAutoIncrement) {\n      sequences.push({\n        sourceName: void 0,\n        start: void 0,\n        minValue: void 0,\n        maxValue: void 0,\n        column: colIds.get(name2),\n        increment: 1n\n      });\n    }\n    if (meta.defaultValue) {\n      const writer = new BinaryWriter(16);\n      builder.serialize(writer, meta.defaultValue);\n      defaultValues.push({\n        colId: colIds.get(name2),\n        value: writer.getBuffer()\n      });\n    }\n    if (scheduled) {\n      const algebraicType = builder.typeBuilder.algebraicType;\n      if (schedule_at_default.isScheduleAt(algebraicType)) {\n        scheduleAtCol = colIds.get(name2);\n      }\n    }\n  }\n  for (const indexOpts of userIndexes ?? []) {\n    const accessor = indexOpts.accessor;\n    if (typeof accessor !== \"string\" || accessor.length === 0) {\n      const tableLabel = name ?? \"<unnamed>\";\n      const indexLabel = indexOpts.name ?? \"<unnamed>\";\n      throw new TypeError(\n        `Index '${indexLabel}' on table '${tableLabel}' must define a non-empty 'accessor'`\n      );\n    }\n    let algorithm;\n    switch (indexOpts.algorithm) {\n      case \"btree\":\n        algorithm = {\n          tag: \"BTree\",\n          value: indexOpts.columns.map((c) => colIds.get(c))\n        };\n        break;\n      case \"hash\":\n        algorithm = {\n          tag: \"Hash\",\n          value: indexOpts.columns.map((c) => colIds.get(c))\n        };\n        break;\n      case \"direct\":\n        algorithm = { tag: \"Direct\", value: colIds.get(indexOpts.column) };\n        break;\n    }\n    indexes.push({\n      sourceName: void 0,\n      accessorName: accessor,\n      algorithm,\n      canonicalName: indexOpts.name\n    });\n  }\n  for (const constraintOpts of opts.constraints ?? []) {\n    if (constraintOpts.constraint === \"unique\") {\n      const data = {\n        tag: \"Unique\",\n        value: { columns: constraintOpts.columns.map((c) => colIds.get(c)) }\n      };\n      constraints.push({ sourceName: constraintOpts.name, data });\n      continue;\n    }\n  }\n  const productType = row.algebraicType.value;\n  const schedule = scheduled && scheduleAtCol !== void 0 ? { scheduleAtCol, reducer: scheduled } : void 0;\n  return {\n    rowType: row,\n    tableName: name,\n    rowSpacetimeType: productType,\n    tableDef: (ctx, accName) => {\n      const tableName = name ?? accName;\n      if (row.typeName === void 0) {\n        row.typeName = toPascalCase(tableName);\n      }\n      for (const index of indexes) {\n        const cols = index.algorithm.tag === \"Direct\" ? [index.algorithm.value] : index.algorithm.value;\n        const colS = cols.map((i) => colNameList[i]).join(\"_\");\n        const sourceName = index.sourceName = `${accName}_${colS}_idx_${index.algorithm.tag.toLowerCase()}`;\n        const { canonicalName } = index;\n        if (canonicalName !== void 0) {\n          ctx.moduleDef.explicitNames.entries.push(\n            ExplicitNameEntry.Index({ sourceName, canonicalName })\n          );\n        }\n      }\n      return {\n        sourceName: accName,\n        productTypeRef: ctx.registerTypesRecursively(row).ref,\n        primaryKey: pk,\n        indexes,\n        constraints,\n        sequences,\n        tableType: { tag: \"User\" },\n        tableAccess: { tag: isPublic ? \"Public\" : \"Private\" },\n        defaultValues,\n        isEvent\n      };\n    },\n    // Preserve the declared index options as runtime data so `tableToSchema`\n    // can expose them without type-smuggling.\n    idxs: userIndexes,\n    constraints,\n    schedule\n  };\n}\n\n// src/lib/query.ts\nvar QueryBrand = Symbol(\"QueryBrand\");\nvar isRowTypedQuery = (val) => !!val && typeof val === \"object\" && QueryBrand in val;\nvar isTypedQuery = (val) => !!val && typeof val === \"object\" && QueryBrand in val;\nfunction toSql(q) {\n  return q.toSql();\n}\nvar SemijoinImpl = class _SemijoinImpl {\n  constructor(sourceQuery, filterQuery, joinCondition) {\n    this.sourceQuery = sourceQuery;\n    this.filterQuery = filterQuery;\n    this.joinCondition = joinCondition;\n    if (sourceQuery.table.sourceName === filterQuery.table.sourceName) {\n      throw new Error(\"Cannot semijoin a table to itself\");\n    }\n  }\n  [QueryBrand] = true;\n  type = \"semijoin\";\n  build() {\n    return this;\n  }\n  where(predicate) {\n    const nextSourceQuery = this.sourceQuery.where(predicate);\n    return new _SemijoinImpl(\n      nextSourceQuery,\n      this.filterQuery,\n      this.joinCondition\n    );\n  }\n  toSql() {\n    const left = this.filterQuery;\n    const right = this.sourceQuery;\n    const leftTable = quoteIdentifier(left.table.sourceName);\n    const rightTable = quoteIdentifier(right.table.sourceName);\n    let sql = `SELECT ${rightTable}.* FROM ${leftTable} JOIN ${rightTable} ON ${booleanExprToSql(this.joinCondition)}`;\n    const clauses = [];\n    if (left.whereClause) {\n      clauses.push(booleanExprToSql(left.whereClause));\n    }\n    if (right.whereClause) {\n      clauses.push(booleanExprToSql(right.whereClause));\n    }\n    if (clauses.length > 0) {\n      const whereSql = clauses.length === 1 ? clauses[0] : clauses.map(wrapInParens).join(\" AND \");\n      sql += ` WHERE ${whereSql}`;\n    }\n    return sql;\n  }\n};\nvar FromBuilder = class _FromBuilder {\n  constructor(table2, whereClause) {\n    this.table = table2;\n    this.whereClause = whereClause;\n  }\n  [QueryBrand] = true;\n  where(predicate) {\n    const newCondition = normalizePredicateExpr(predicate(this.table.cols));\n    const nextWhere = this.whereClause ? this.whereClause.and(newCondition) : newCondition;\n    return new _FromBuilder(this.table, nextWhere);\n  }\n  rightSemijoin(right, on) {\n    const sourceQuery = new _FromBuilder(right);\n    const joinCondition = on(\n      this.table.indexedCols,\n      right.indexedCols\n    );\n    return new SemijoinImpl(sourceQuery, this, joinCondition);\n  }\n  leftSemijoin(right, on) {\n    const filterQuery = new _FromBuilder(right);\n    const joinCondition = on(\n      this.table.indexedCols,\n      right.indexedCols\n    );\n    return new SemijoinImpl(this, filterQuery, joinCondition);\n  }\n  toSql() {\n    return renderSelectSqlWithJoins(this.table, this.whereClause);\n  }\n  build() {\n    return this;\n  }\n};\nvar TableRefImpl = class {\n  [QueryBrand] = true;\n  type = \"table\";\n  sourceName;\n  accessorName;\n  cols;\n  indexedCols;\n  tableDef;\n  // Delegate UntypedTableDef properties from tableDef so this can be used as a table def.\n  get columns() {\n    return this.tableDef.columns;\n  }\n  get indexes() {\n    return this.tableDef.indexes;\n  }\n  get rowType() {\n    return this.tableDef.rowType;\n  }\n  get constraints() {\n    return this.tableDef.constraints;\n  }\n  constructor(tableDef) {\n    this.sourceName = tableDef.sourceName;\n    this.accessorName = tableDef.accessorName;\n    this.cols = createRowExpr(tableDef);\n    this.indexedCols = this.cols;\n    this.tableDef = tableDef;\n    Object.freeze(this);\n  }\n  asFrom() {\n    return new FromBuilder(this);\n  }\n  rightSemijoin(other, on) {\n    return this.asFrom().rightSemijoin(other, on);\n  }\n  leftSemijoin(other, on) {\n    return this.asFrom().leftSemijoin(other, on);\n  }\n  build() {\n    return this.asFrom().build();\n  }\n  toSql() {\n    return this.asFrom().toSql();\n  }\n  where(predicate) {\n    return this.asFrom().where(predicate);\n  }\n};\nfunction createTableRefFromDef(tableDef) {\n  return new TableRefImpl(tableDef);\n}\nfunction makeQueryBuilder(schema2) {\n  const qb = /* @__PURE__ */ Object.create(null);\n  for (const table2 of Object.values(schema2.tables)) {\n    const ref = createTableRefFromDef(\n      table2\n    );\n    qb[table2.accessorName] = ref;\n  }\n  return Object.freeze(qb);\n}\nfunction createRowExpr(tableDef) {\n  const row = {};\n  for (const columnName of Object.keys(tableDef.columns)) {\n    const columnBuilder = tableDef.columns[columnName];\n    const column = new ColumnExpression(\n      tableDef.sourceName,\n      columnName,\n      columnBuilder.typeBuilder.algebraicType,\n      columnBuilder.columnMetadata.name\n    );\n    row[columnName] = Object.freeze(column);\n  }\n  return Object.freeze(row);\n}\nfunction renderSelectSqlWithJoins(table2, where, extraClauses = []) {\n  const quotedTable = quoteIdentifier(table2.sourceName);\n  const sql = `SELECT * FROM ${quotedTable}`;\n  const clauses = [];\n  if (where) clauses.push(booleanExprToSql(where));\n  clauses.push(...extraClauses);\n  if (clauses.length === 0) return sql;\n  const whereSql = clauses.length === 1 ? clauses[0] : clauses.map(wrapInParens).join(\" AND \");\n  return `${sql} WHERE ${whereSql}`;\n}\nvar ColumnExpression = class {\n  type = \"column\";\n  // This is the column accessor\n  column;\n  // The name of the column in the database.\n  columnName;\n  table;\n  // phantom: actual runtime value is undefined\n  tsValueType;\n  spacetimeType;\n  constructor(table2, column, spacetimeType, columnName) {\n    this.table = table2;\n    this.column = column;\n    this.columnName = columnName || column;\n    this.spacetimeType = spacetimeType;\n  }\n  eq(x) {\n    return new BooleanExpr({\n      type: \"eq\",\n      left: this,\n      right: normalizeValue(x)\n    });\n  }\n  ne(x) {\n    return new BooleanExpr({\n      type: \"ne\",\n      left: this,\n      right: normalizeValue(x)\n    });\n  }\n  lt(x) {\n    return new BooleanExpr({\n      type: \"lt\",\n      left: this,\n      right: normalizeValue(x)\n    });\n  }\n  lte(x) {\n    return new BooleanExpr({\n      type: \"lte\",\n      left: this,\n      right: normalizeValue(x)\n    });\n  }\n  gt(x) {\n    return new BooleanExpr({\n      type: \"gt\",\n      left: this,\n      right: normalizeValue(x)\n    });\n  }\n  gte(x) {\n    return new BooleanExpr({\n      type: \"gte\",\n      left: this,\n      right: normalizeValue(x)\n    });\n  }\n};\nfunction literal(value) {\n  return { type: \"literal\", value };\n}\nfunction normalizeValue(val) {\n  if (val.type === \"literal\")\n    return val;\n  if (typeof val === \"object\" && val != null && \"type\" in val && val.type === \"column\") {\n    return val;\n  }\n  return literal(val);\n}\nfunction normalizePredicateExpr(value) {\n  if (value instanceof BooleanExpr) return value;\n  if (typeof value === \"boolean\") {\n    return new BooleanExpr({\n      type: \"eq\",\n      left: literal(value),\n      right: literal(true)\n    });\n  }\n  return new BooleanExpr({\n    type: \"eq\",\n    left: value,\n    right: literal(true)\n  });\n}\nvar BooleanExpr = class _BooleanExpr {\n  constructor(data) {\n    this.data = data;\n  }\n  and(other) {\n    return new _BooleanExpr({\n      type: \"and\",\n      clauses: [this.data, other.data]\n    });\n  }\n  or(other) {\n    return new _BooleanExpr({\n      type: \"or\",\n      clauses: [this.data, other.data]\n    });\n  }\n  not() {\n    return new _BooleanExpr({ type: \"not\", clause: this.data });\n  }\n};\nfunction not(clause) {\n  return new BooleanExpr({ type: \"not\", clause: clause.data });\n}\nfunction and(first, second, ...rest) {\n  const clauses = [first, second, ...rest];\n  return new BooleanExpr({\n    type: \"and\",\n    clauses: clauses.map((c) => c.data)\n  });\n}\nfunction or(first, second, ...rest) {\n  const clauses = [first, second, ...rest];\n  return new BooleanExpr({\n    type: \"or\",\n    clauses: clauses.map((c) => c.data)\n  });\n}\nfunction booleanExprToSql(expr, tableAlias) {\n  const data = expr instanceof BooleanExpr ? expr.data : expr;\n  switch (data.type) {\n    case \"eq\":\n      return `${valueExprToSql(data.left)} = ${valueExprToSql(data.right)}`;\n    case \"ne\":\n      return `${valueExprToSql(data.left)} <> ${valueExprToSql(data.right)}`;\n    case \"gt\":\n      return `${valueExprToSql(data.left)} > ${valueExprToSql(data.right)}`;\n    case \"gte\":\n      return `${valueExprToSql(data.left)} >= ${valueExprToSql(data.right)}`;\n    case \"lt\":\n      return `${valueExprToSql(data.left)} < ${valueExprToSql(data.right)}`;\n    case \"lte\":\n      return `${valueExprToSql(data.left)} <= ${valueExprToSql(data.right)}`;\n    case \"and\":\n      return data.clauses.map((c) => booleanExprToSql(c)).map(wrapInParens).join(\" AND \");\n    case \"or\":\n      return data.clauses.map((c) => booleanExprToSql(c)).map(wrapInParens).join(\" OR \");\n    case \"not\":\n      return `NOT ${wrapInParens(booleanExprToSql(data.clause))}`;\n  }\n}\nfunction wrapInParens(sql) {\n  return `(${sql})`;\n}\nfunction valueExprToSql(expr, tableAlias) {\n  if (isLiteralExpr(expr)) {\n    return literalValueToSql(expr.value);\n  }\n  const table2 = expr.table;\n  return `${quoteIdentifier(table2)}.${quoteIdentifier(expr.columnName)}`;\n}\nfunction literalValueToSql(value) {\n  if (value === null || value === void 0) {\n    return \"NULL\";\n  }\n  if (value instanceof Identity || value instanceof ConnectionId) {\n    return `0x${value.toHexString()}`;\n  }\n  if (value instanceof Timestamp) {\n    return `'${value.toISOString()}'`;\n  }\n  switch (typeof value) {\n    case \"number\":\n    case \"bigint\":\n      return String(value);\n    case \"boolean\":\n      return value ? \"TRUE\" : \"FALSE\";\n    case \"string\":\n      return `'${value.replace(/'/g, \"''\")}'`;\n    default:\n      return `'${JSON.stringify(value).replace(/'/g, \"''\")}'`;\n  }\n}\nfunction quoteIdentifier(name) {\n  return `\"${name.replace(/\"/g, '\"\"')}\"`;\n}\nfunction isLiteralExpr(expr) {\n  return expr.type === \"literal\";\n}\nfunction evaluateBooleanExpr(expr, row) {\n  return evaluateData(expr.data, row);\n}\nfunction evaluateData(data, row) {\n  switch (data.type) {\n    case \"eq\":\n      return resolveValue(data.left, row) === resolveValue(data.right, row);\n    case \"ne\":\n      return resolveValue(data.left, row) !== resolveValue(data.right, row);\n    case \"gt\":\n      return resolveValue(data.left, row) > resolveValue(data.right, row);\n    case \"gte\":\n      return resolveValue(data.left, row) >= resolveValue(data.right, row);\n    case \"lt\":\n      return resolveValue(data.left, row) < resolveValue(data.right, row);\n    case \"lte\":\n      return resolveValue(data.left, row) <= resolveValue(data.right, row);\n    case \"and\":\n      return data.clauses.every((c) => evaluateData(c, row));\n    case \"or\":\n      return data.clauses.some((c) => evaluateData(c, row));\n    case \"not\":\n      return !evaluateData(data.clause, row);\n  }\n}\nfunction resolveValue(expr, row) {\n  if (isLiteralExpr(expr)) {\n    return toComparableValue(expr.value);\n  }\n  return toComparableValue(row[expr.column]);\n}\nfunction isHexSerializableLike(value) {\n  return !!value && typeof value === \"object\" && typeof value.toHexString === \"function\";\n}\nfunction isTimestampLike(value) {\n  if (!value || typeof value !== \"object\") return false;\n  if (value instanceof Timestamp) return true;\n  const micros = value[\"__timestamp_micros_since_unix_epoch__\"];\n  return typeof micros === \"bigint\";\n}\nfunction toComparableValue(value) {\n  if (isHexSerializableLike(value)) {\n    return value.toHexString();\n  }\n  if (isTimestampLike(value)) {\n    return value.__timestamp_micros_since_unix_epoch__;\n  }\n  return value;\n}\nfunction getQueryTableName(query) {\n  if (query.table) return query.table.name;\n  if (query.name) return query.name;\n  if (query.sourceQuery) return query.sourceQuery.table.name;\n  throw new Error(\"Cannot extract table name from query\");\n}\nfunction getQueryAccessorName(query) {\n  if (query.table) return query.table.accessorName;\n  if (query.accessorName) return query.accessorName;\n  if (query.sourceQuery) return query.sourceQuery.table.accessorName;\n  throw new Error(\"Cannot extract accessor name from query\");\n}\nfunction getQueryWhereClause(query) {\n  if (query.whereClause) return query.whereClause;\n  return void 0;\n}\n\n// src/server/views.ts\nfunction makeViewExport(ctx, opts, params, ret, fn) {\n  const viewExport = (\n    // @ts-expect-error typescript incorrectly says Function#bind requires an argument.\n    fn.bind()\n  );\n  viewExport[exportContext] = ctx;\n  viewExport[registerExport] = (ctx2, exportName) => {\n    registerView(ctx2, opts, exportName, false, params, ret, fn);\n  };\n  return viewExport;\n}\nfunction makeAnonViewExport(ctx, opts, params, ret, fn) {\n  const viewExport = (\n    // @ts-expect-error typescript incorrectly says Function#bind requires an argument.\n    fn.bind()\n  );\n  viewExport[exportContext] = ctx;\n  viewExport[registerExport] = (ctx2, exportName) => {\n    registerView(ctx2, opts, exportName, true, params, ret, fn);\n  };\n  return viewExport;\n}\nfunction registerView(ctx, opts, exportName, anon, params, ret, fn) {\n  const paramsBuilder = new RowBuilder(params, toPascalCase(exportName));\n  let returnType = ctx.registerTypesRecursively(ret).algebraicType;\n  const { typespace } = ctx;\n  const { value: paramType } = ctx.resolveType(\n    ctx.registerTypesRecursively(paramsBuilder)\n  );\n  ctx.moduleDef.views.push({\n    sourceName: exportName,\n    index: (anon ? ctx.anonViews : ctx.views).length,\n    isPublic: opts.public,\n    isAnonymous: anon,\n    params: paramType,\n    returnType\n  });\n  if (opts.name != null) {\n    ctx.moduleDef.explicitNames.entries.push({\n      tag: \"Function\",\n      value: {\n        sourceName: exportName,\n        canonicalName: opts.name\n      }\n    });\n  }\n  if (returnType.tag == \"Sum\") {\n    const originalFn = fn;\n    fn = ((ctx2, args) => {\n      const ret2 = originalFn(ctx2, args);\n      return ret2 == null ? [] : [ret2];\n    });\n    returnType = AlgebraicType.Array(\n      returnType.value.variants[0].algebraicType\n    );\n  }\n  (anon ? ctx.anonViews : ctx.views).push({\n    fn,\n    deserializeParams: ProductType.makeDeserializer(paramType, typespace),\n    serializeReturn: AlgebraicType.makeSerializer(returnType, typespace),\n    returnTypeBaseSize: bsatnBaseSize(typespace, returnType)\n  });\n}\n\n// src/lib/errors.ts\nvar SenderError = class extends Error {\n  constructor(message) {\n    super(message);\n  }\n  get name() {\n    return \"SenderError\";\n  }\n};\n\n// src/server/errors.ts\nvar SpacetimeHostError = class extends Error {\n  constructor(message) {\n    super(message);\n  }\n  get name() {\n    return \"SpacetimeHostError\";\n  }\n};\nvar errorData = {\n  /**\n   * A generic error class for unknown error codes.\n   */\n  HostCallFailure: 1,\n  /**\n   * Error indicating that an ABI call was made outside of a transaction.\n   */\n  NotInTransaction: 2,\n  /**\n   * Error indicating that BSATN decoding failed.\n   * This typically means that the data could not be decoded to the expected type.\n   */\n  BsatnDecodeError: 3,\n  /**\n   * Error indicating that a specified table does not exist.\n   */\n  NoSuchTable: 4,\n  /**\n   * Error indicating that a specified index does not exist.\n   */\n  NoSuchIndex: 5,\n  /**\n   * Error indicating that a specified row iterator is not valid.\n   */\n  NoSuchIter: 6,\n  /**\n   * Error indicating that a specified console timer does not exist.\n   */\n  NoSuchConsoleTimer: 7,\n  /**\n   * Error indicating that a specified bytes source or sink is not valid.\n   */\n  NoSuchBytes: 8,\n  /**\n   * Error indicating that a provided sink has no more space left.\n   */\n  NoSpace: 9,\n  /**\n   * Error indicating that there is no more space in the database.\n   */\n  BufferTooSmall: 11,\n  /**\n   * Error indicating that a value with a given unique identifier already exists.\n   */\n  UniqueAlreadyExists: 12,\n  /**\n   * Error indicating that the specified delay in scheduling a row was too long.\n   */\n  ScheduleAtDelayTooLong: 13,\n  /**\n   * Error indicating that an index was not unique when it was expected to be.\n   */\n  IndexNotUnique: 14,\n  /**\n   * Error indicating that an index was not unique when it was expected to be.\n   */\n  NoSuchRow: 15,\n  /**\n   * Error indicating that an auto-increment sequence has overflowed.\n   */\n  AutoIncOverflow: 16,\n  WouldBlockTransaction: 17,\n  TransactionNotAnonymous: 18,\n  TransactionIsReadOnly: 19,\n  TransactionIsMut: 20,\n  HttpError: 21\n};\nfunction mapEntries(x, f) {\n  return Object.fromEntries(\n    Object.entries(x).map(([k, v]) => [k, f(k, v)])\n  );\n}\nvar errnoToClass = /* @__PURE__ */ new Map();\nvar errors = Object.freeze(\n  mapEntries(errorData, (name, code) => {\n    const cls = Object.defineProperty(\n      class extends SpacetimeHostError {\n        get name() {\n          return name;\n        }\n      },\n      \"name\",\n      { value: name, writable: false }\n    );\n    errnoToClass.set(code, cls);\n    return cls;\n  })\n);\nfunction getErrorConstructor(code) {\n  return errnoToClass.get(code) ?? SpacetimeHostError;\n}\n\n// ../../node_modules/.pnpm/pure-rand@7.0.1/node_modules/pure-rand/lib/esm/distribution/UnsafeUniformBigIntDistribution.js\nvar SBigInt = typeof BigInt !== \"undefined\" ? BigInt : void 0;\nvar One = typeof BigInt !== \"undefined\" ? BigInt(1) : void 0;\nvar ThirtyTwo = typeof BigInt !== \"undefined\" ? BigInt(32) : void 0;\nvar NumValues = typeof BigInt !== \"undefined\" ? BigInt(4294967296) : void 0;\nfunction unsafeUniformBigIntDistribution(from, to, rng) {\n  var diff = to - from + One;\n  var FinalNumValues = NumValues;\n  var NumIterations = 1;\n  while (FinalNumValues < diff) {\n    FinalNumValues <<= ThirtyTwo;\n    ++NumIterations;\n  }\n  var value = generateNext(NumIterations, rng);\n  if (value < diff) {\n    return value + from;\n  }\n  if (value + diff < FinalNumValues) {\n    return value % diff + from;\n  }\n  var MaxAcceptedRandom = FinalNumValues - FinalNumValues % diff;\n  while (value >= MaxAcceptedRandom) {\n    value = generateNext(NumIterations, rng);\n  }\n  return value % diff + from;\n}\nfunction generateNext(NumIterations, rng) {\n  var value = SBigInt(rng.unsafeNext() + 2147483648);\n  for (var num = 1; num < NumIterations; ++num) {\n    var out = rng.unsafeNext();\n    value = (value << ThirtyTwo) + SBigInt(out + 2147483648);\n  }\n  return value;\n}\n\n// ../../node_modules/.pnpm/pure-rand@7.0.1/node_modules/pure-rand/lib/esm/distribution/internals/UnsafeUniformIntDistributionInternal.js\nfunction unsafeUniformIntDistributionInternal(rangeSize, rng) {\n  var MaxAllowed = rangeSize > 2 ? ~~(4294967296 / rangeSize) * rangeSize : 4294967296;\n  var deltaV = rng.unsafeNext() + 2147483648;\n  while (deltaV >= MaxAllowed) {\n    deltaV = rng.unsafeNext() + 2147483648;\n  }\n  return deltaV % rangeSize;\n}\n\n// ../../node_modules/.pnpm/pure-rand@7.0.1/node_modules/pure-rand/lib/esm/distribution/internals/ArrayInt64.js\nfunction fromNumberToArrayInt64(out, n) {\n  if (n < 0) {\n    var posN = -n;\n    out.sign = -1;\n    out.data[0] = ~~(posN / 4294967296);\n    out.data[1] = posN >>> 0;\n  } else {\n    out.sign = 1;\n    out.data[0] = ~~(n / 4294967296);\n    out.data[1] = n >>> 0;\n  }\n  return out;\n}\nfunction substractArrayInt64(out, arrayIntA, arrayIntB) {\n  var lowA = arrayIntA.data[1];\n  var highA = arrayIntA.data[0];\n  var signA = arrayIntA.sign;\n  var lowB = arrayIntB.data[1];\n  var highB = arrayIntB.data[0];\n  var signB = arrayIntB.sign;\n  out.sign = 1;\n  if (signA === 1 && signB === -1) {\n    var low_1 = lowA + lowB;\n    var high = highA + highB + (low_1 > 4294967295 ? 1 : 0);\n    out.data[0] = high >>> 0;\n    out.data[1] = low_1 >>> 0;\n    return out;\n  }\n  var lowFirst = lowA;\n  var highFirst = highA;\n  var lowSecond = lowB;\n  var highSecond = highB;\n  if (signA === -1) {\n    lowFirst = lowB;\n    highFirst = highB;\n    lowSecond = lowA;\n    highSecond = highA;\n  }\n  var reminderLow = 0;\n  var low = lowFirst - lowSecond;\n  if (low < 0) {\n    reminderLow = 1;\n    low = low >>> 0;\n  }\n  out.data[0] = highFirst - highSecond - reminderLow;\n  out.data[1] = low;\n  return out;\n}\n\n// ../../node_modules/.pnpm/pure-rand@7.0.1/node_modules/pure-rand/lib/esm/distribution/internals/UnsafeUniformArrayIntDistributionInternal.js\nfunction unsafeUniformArrayIntDistributionInternal(out, rangeSize, rng) {\n  var rangeLength = rangeSize.length;\n  while (true) {\n    for (var index = 0; index !== rangeLength; ++index) {\n      var indexRangeSize = index === 0 ? rangeSize[0] + 1 : 4294967296;\n      var g = unsafeUniformIntDistributionInternal(indexRangeSize, rng);\n      out[index] = g;\n    }\n    for (var index = 0; index !== rangeLength; ++index) {\n      var current = out[index];\n      var currentInRange = rangeSize[index];\n      if (current < currentInRange) {\n        return out;\n      } else if (current > currentInRange) {\n        break;\n      }\n    }\n  }\n}\n\n// ../../node_modules/.pnpm/pure-rand@7.0.1/node_modules/pure-rand/lib/esm/distribution/UnsafeUniformIntDistribution.js\nvar safeNumberMaxSafeInteger = Number.MAX_SAFE_INTEGER;\nvar sharedA = { sign: 1, data: [0, 0] };\nvar sharedB = { sign: 1, data: [0, 0] };\nvar sharedC = { sign: 1, data: [0, 0] };\nvar sharedData = [0, 0];\nfunction uniformLargeIntInternal(from, to, rangeSize, rng) {\n  var rangeSizeArrayIntValue = rangeSize <= safeNumberMaxSafeInteger ? fromNumberToArrayInt64(sharedC, rangeSize) : substractArrayInt64(sharedC, fromNumberToArrayInt64(sharedA, to), fromNumberToArrayInt64(sharedB, from));\n  if (rangeSizeArrayIntValue.data[1] === 4294967295) {\n    rangeSizeArrayIntValue.data[0] += 1;\n    rangeSizeArrayIntValue.data[1] = 0;\n  } else {\n    rangeSizeArrayIntValue.data[1] += 1;\n  }\n  unsafeUniformArrayIntDistributionInternal(sharedData, rangeSizeArrayIntValue.data, rng);\n  return sharedData[0] * 4294967296 + sharedData[1] + from;\n}\nfunction unsafeUniformIntDistribution(from, to, rng) {\n  var rangeSize = to - from;\n  if (rangeSize <= 4294967295) {\n    var g = unsafeUniformIntDistributionInternal(rangeSize + 1, rng);\n    return g + from;\n  }\n  return uniformLargeIntInternal(from, to, rangeSize, rng);\n}\n\n// ../../node_modules/.pnpm/pure-rand@7.0.1/node_modules/pure-rand/lib/esm/generator/XoroShiro.js\nvar XoroShiro128Plus = (function() {\n  function XoroShiro128Plus2(s01, s00, s11, s10) {\n    this.s01 = s01;\n    this.s00 = s00;\n    this.s11 = s11;\n    this.s10 = s10;\n  }\n  XoroShiro128Plus2.prototype.clone = function() {\n    return new XoroShiro128Plus2(this.s01, this.s00, this.s11, this.s10);\n  };\n  XoroShiro128Plus2.prototype.next = function() {\n    var nextRng = new XoroShiro128Plus2(this.s01, this.s00, this.s11, this.s10);\n    var out = nextRng.unsafeNext();\n    return [out, nextRng];\n  };\n  XoroShiro128Plus2.prototype.unsafeNext = function() {\n    var out = this.s00 + this.s10 | 0;\n    var a0 = this.s10 ^ this.s00;\n    var a1 = this.s11 ^ this.s01;\n    var s00 = this.s00;\n    var s01 = this.s01;\n    this.s00 = s00 << 24 ^ s01 >>> 8 ^ a0 ^ a0 << 16;\n    this.s01 = s01 << 24 ^ s00 >>> 8 ^ a1 ^ (a1 << 16 | a0 >>> 16);\n    this.s10 = a1 << 5 ^ a0 >>> 27;\n    this.s11 = a0 << 5 ^ a1 >>> 27;\n    return out;\n  };\n  XoroShiro128Plus2.prototype.jump = function() {\n    var nextRng = new XoroShiro128Plus2(this.s01, this.s00, this.s11, this.s10);\n    nextRng.unsafeJump();\n    return nextRng;\n  };\n  XoroShiro128Plus2.prototype.unsafeJump = function() {\n    var ns01 = 0;\n    var ns00 = 0;\n    var ns11 = 0;\n    var ns10 = 0;\n    var jump = [3639956645, 3750757012, 1261568508, 386426335];\n    for (var i = 0; i !== 4; ++i) {\n      for (var mask = 1; mask; mask <<= 1) {\n        if (jump[i] & mask) {\n          ns01 ^= this.s01;\n          ns00 ^= this.s00;\n          ns11 ^= this.s11;\n          ns10 ^= this.s10;\n        }\n        this.unsafeNext();\n      }\n    }\n    this.s01 = ns01;\n    this.s00 = ns00;\n    this.s11 = ns11;\n    this.s10 = ns10;\n  };\n  XoroShiro128Plus2.prototype.getState = function() {\n    return [this.s01, this.s00, this.s11, this.s10];\n  };\n  return XoroShiro128Plus2;\n})();\nfunction fromState(state) {\n  var valid = state.length === 4;\n  if (!valid) {\n    throw new Error(\"The state must have been produced by a xoroshiro128plus RandomGenerator\");\n  }\n  return new XoroShiro128Plus(state[0], state[1], state[2], state[3]);\n}\nvar xoroshiro128plus = Object.assign(function(seed) {\n  return new XoroShiro128Plus(-1, ~seed, seed | 0, 0);\n}, { fromState });\n\n// src/server/rng.ts\nvar { asUintN } = BigInt;\nfunction pcg32(state) {\n  const MUL = 6364136223846793005n;\n  const INC = 11634580027462260723n;\n  state = asUintN(64, state * MUL + INC);\n  const xorshifted = Number(asUintN(32, (state >> 18n ^ state) >> 27n));\n  const rot = Number(asUintN(32, state >> 59n));\n  return xorshifted >> rot | xorshifted << 32 - rot;\n}\nfunction generateFloat64(rng) {\n  const g1 = unsafeUniformIntDistribution(0, (1 << 26) - 1, rng);\n  const g2 = unsafeUniformIntDistribution(0, (1 << 27) - 1, rng);\n  const value = (g1 * Math.pow(2, 27) + g2) * Math.pow(2, -53);\n  return value;\n}\nfunction makeRandom(seed) {\n  const rng = xoroshiro128plus(pcg32(seed.microsSinceUnixEpoch));\n  const random = () => generateFloat64(rng);\n  random.fill = (array) => {\n    const elem = array.at(0);\n    if (typeof elem === \"bigint\") {\n      const upper = (1n << BigInt(array.BYTES_PER_ELEMENT * 8)) - 1n;\n      for (let i = 0; i < array.length; i++) {\n        array[i] = unsafeUniformBigIntDistribution(0n, upper, rng);\n      }\n    } else if (typeof elem === \"number\") {\n      const upper = (1 << array.BYTES_PER_ELEMENT * 8) - 1;\n      for (let i = 0; i < array.length; i++) {\n        array[i] = unsafeUniformIntDistribution(0, upper, rng);\n      }\n    }\n    return array;\n  };\n  random.uint32 = () => rng.unsafeNext();\n  random.integerInRange = (min, max) => unsafeUniformIntDistribution(min, max, rng);\n  random.bigintInRange = (min, max) => unsafeUniformBigIntDistribution(min, max, rng);\n  return random;\n}\n\n// src/server/runtime.ts\nvar { freeze } = Object;\nvar sys = _syscalls2_0;\nfunction parseJsonObject(json) {\n  let value;\n  try {\n    value = JSON.parse(json);\n  } catch {\n    throw new Error(\"Invalid JSON: failed to parse string\");\n  }\n  if (value === null || typeof value !== \"object\" || Array.isArray(value)) {\n    throw new Error(\"Expected a JSON object at the top level\");\n  }\n  return value;\n}\nvar JwtClaimsImpl = class {\n  /**\n   * Creates a new JwtClaims instance.\n   * @param rawPayload The JWT payload as a raw JSON string.\n   * @param identity The identity for this JWT. We are only taking this because we don't have a blake3 implementation (which we need to compute it).\n   */\n  constructor(rawPayload, identity) {\n    this.rawPayload = rawPayload;\n    this.fullPayload = parseJsonObject(rawPayload);\n    this._identity = identity;\n  }\n  fullPayload;\n  _identity;\n  get identity() {\n    return this._identity;\n  }\n  get subject() {\n    return this.fullPayload[\"sub\"];\n  }\n  get issuer() {\n    return this.fullPayload[\"iss\"];\n  }\n  get audience() {\n    const aud = this.fullPayload[\"aud\"];\n    if (aud == null) {\n      return [];\n    }\n    return typeof aud === \"string\" ? [aud] : aud;\n  }\n};\nvar AuthCtxImpl = class _AuthCtxImpl {\n  isInternal;\n  // Source of the JWT payload string, if there is one.\n  _jwtSource;\n  // Whether we have initialized the JWT claims.\n  _initializedJWT = false;\n  _jwtClaims;\n  _senderIdentity;\n  constructor(opts) {\n    this.isInternal = opts.isInternal;\n    this._jwtSource = opts.jwtSource;\n    this._senderIdentity = opts.senderIdentity;\n  }\n  _initializeJWT() {\n    if (this._initializedJWT) return;\n    this._initializedJWT = true;\n    const token = this._jwtSource();\n    if (!token) {\n      this._jwtClaims = null;\n    } else {\n      this._jwtClaims = new JwtClaimsImpl(token, this._senderIdentity);\n    }\n    Object.freeze(this);\n  }\n  /** Lazily compute whether a JWT exists and is parseable. */\n  get hasJWT() {\n    this._initializeJWT();\n    return this._jwtClaims !== null;\n  }\n  /** Lazily parse the JwtClaims only when accessed. */\n  get jwt() {\n    this._initializeJWT();\n    return this._jwtClaims;\n  }\n  /** Create a context representing internal (non-user) requests. */\n  static internal() {\n    return new _AuthCtxImpl({\n      isInternal: true,\n      jwtSource: () => null,\n      senderIdentity: Identity.zero()\n    });\n  }\n  /** If there is a connection id, look up the JWT payload from the system tables. */\n  static fromSystemTables(connectionId, sender) {\n    if (connectionId === null) {\n      return new _AuthCtxImpl({\n        isInternal: false,\n        jwtSource: () => null,\n        senderIdentity: sender\n      });\n    }\n    return new _AuthCtxImpl({\n      isInternal: false,\n      jwtSource: () => {\n        const payloadBuf = sys.get_jwt_payload(connectionId.__connection_id__);\n        if (payloadBuf.length === 0) return null;\n        const payloadStr = new TextDecoder().decode(payloadBuf);\n        return payloadStr;\n      },\n      senderIdentity: sender\n    });\n  }\n};\nvar ReducerCtxImpl = class ReducerCtx {\n  #identity;\n  #senderAuth;\n  #uuidCounter;\n  #random;\n  sender;\n  timestamp;\n  connectionId;\n  db;\n  constructor(sender, timestamp, connectionId, dbView) {\n    Object.seal(this);\n    this.sender = sender;\n    this.timestamp = timestamp;\n    this.connectionId = connectionId;\n    this.db = dbView;\n  }\n  /** Reset the `ReducerCtx` to be used for a new transaction */\n  static reset(me, sender, timestamp, connectionId) {\n    me.sender = sender;\n    me.timestamp = timestamp;\n    me.connectionId = connectionId;\n    me.#uuidCounter = void 0;\n    me.#senderAuth = void 0;\n  }\n  get identity() {\n    return this.#identity ??= new Identity(sys.identity());\n  }\n  get senderAuth() {\n    return this.#senderAuth ??= AuthCtxImpl.fromSystemTables(\n      this.connectionId,\n      this.sender\n    );\n  }\n  get random() {\n    return this.#random ??= makeRandom(this.timestamp);\n  }\n  /**\n   * Create a new random {@link Uuid} `v4` using this `ReducerCtx`'s RNG.\n   */\n  newUuidV4() {\n    const bytes = this.random.fill(new Uint8Array(16));\n    return Uuid.fromRandomBytesV4(bytes);\n  }\n  /**\n   * Create a new sortable {@link Uuid} `v7` using this `ReducerCtx`'s RNG, counter,\n   * and timestamp.\n   */\n  newUuidV7() {\n    const bytes = this.random.fill(new Uint8Array(4));\n    const counter = this.#uuidCounter ??= { value: 0 };\n    return Uuid.fromCounterV7(counter, this.timestamp, bytes);\n  }\n};\nvar callUserFunction = function __spacetimedb_end_short_backtrace(fn, ...args) {\n  return fn(...args);\n};\nvar makeHooks = (schema2) => new ModuleHooksImpl(schema2);\nvar ModuleHooksImpl = class {\n  #schema;\n  #dbView_;\n  #reducerArgsDeserializers;\n  /** Cache the `ReducerCtx` object to avoid allocating anew for ever reducer call. */\n  #reducerCtx_;\n  constructor(schema2) {\n    this.#schema = schema2;\n    this.#reducerArgsDeserializers = schema2.moduleDef.reducers.map(\n      ({ params }) => ProductType.makeDeserializer(params, schema2.typespace)\n    );\n  }\n  get #dbView() {\n    return this.#dbView_ ??= freeze(\n      Object.fromEntries(\n        Object.values(this.#schema.schemaType.tables).map((table2) => [\n          table2.accessorName,\n          makeTableView(this.#schema.typespace, table2.tableDef)\n        ])\n      )\n    );\n  }\n  get #reducerCtx() {\n    return this.#reducerCtx_ ??= new ReducerCtxImpl(\n      Identity.zero(),\n      Timestamp.UNIX_EPOCH,\n      null,\n      this.#dbView\n    );\n  }\n  __describe_module__() {\n    const writer = new BinaryWriter(128);\n    RawModuleDef.serialize(\n      writer,\n      RawModuleDef.V10(this.#schema.rawModuleDefV10())\n    );\n    return writer.getBuffer();\n  }\n  __get_error_constructor__(code) {\n    return getErrorConstructor(code);\n  }\n  get __sender_error_class__() {\n    return SenderError;\n  }\n  __call_reducer__(reducerId, sender, connId, timestamp, argsBuf) {\n    const moduleCtx = this.#schema;\n    const deserializeArgs = this.#reducerArgsDeserializers[reducerId];\n    BINARY_READER.reset(argsBuf);\n    const args = deserializeArgs(BINARY_READER);\n    const senderIdentity = new Identity(sender);\n    const ctx = this.#reducerCtx;\n    ReducerCtxImpl.reset(\n      ctx,\n      senderIdentity,\n      new Timestamp(timestamp),\n      ConnectionId.nullIfZero(new ConnectionId(connId))\n    );\n    callUserFunction(moduleCtx.reducers[reducerId], ctx, args);\n  }\n  __call_view__(id, sender, argsBuf) {\n    const moduleCtx = this.#schema;\n    const { fn, deserializeParams, serializeReturn, returnTypeBaseSize } = moduleCtx.views[id];\n    const ctx = freeze({\n      sender: new Identity(sender),\n      // this is the non-readonly DbView, but the typing for the user will be\n      // the readonly one, and if they do call mutating functions it will fail\n      // at runtime\n      db: this.#dbView,\n      from: makeQueryBuilder(moduleCtx.schemaType)\n    });\n    const args = deserializeParams(new BinaryReader(argsBuf));\n    const ret = callUserFunction(fn, ctx, args);\n    const retBuf = new BinaryWriter(returnTypeBaseSize);\n    if (isRowTypedQuery(ret)) {\n      const query = toSql(ret);\n      ViewResultHeader.serialize(retBuf, ViewResultHeader.RawSql(query));\n    } else {\n      ViewResultHeader.serialize(retBuf, ViewResultHeader.RowData);\n      serializeReturn(retBuf, ret);\n    }\n    return { data: retBuf.getBuffer() };\n  }\n  __call_view_anon__(id, argsBuf) {\n    const moduleCtx = this.#schema;\n    const { fn, deserializeParams, serializeReturn, returnTypeBaseSize } = moduleCtx.anonViews[id];\n    const ctx = freeze({\n      // this is the non-readonly DbView, but the typing for the user will be\n      // the readonly one, and if they do call mutating functions it will fail\n      // at runtime\n      db: this.#dbView,\n      from: makeQueryBuilder(moduleCtx.schemaType)\n    });\n    const args = deserializeParams(new BinaryReader(argsBuf));\n    const ret = callUserFunction(fn, ctx, args);\n    const retBuf = new BinaryWriter(returnTypeBaseSize);\n    if (isRowTypedQuery(ret)) {\n      const query = toSql(ret);\n      ViewResultHeader.serialize(retBuf, ViewResultHeader.RawSql(query));\n    } else {\n      ViewResultHeader.serialize(retBuf, ViewResultHeader.RowData);\n      serializeReturn(retBuf, ret);\n    }\n    return { data: retBuf.getBuffer() };\n  }\n  __call_procedure__(id, sender, connection_id, timestamp, args) {\n    return callProcedure(\n      this.#schema,\n      id,\n      new Identity(sender),\n      ConnectionId.nullIfZero(new ConnectionId(connection_id)),\n      new Timestamp(timestamp),\n      args,\n      () => this.#dbView\n    );\n  }\n};\nvar BINARY_WRITER = new BinaryWriter(0);\nvar BINARY_READER = new BinaryReader(new Uint8Array());\nfunction makeTableView(typespace, table2) {\n  const table_id = sys.table_id_from_name(table2.sourceName);\n  const rowType = typespace.types[table2.productTypeRef];\n  if (rowType.tag !== \"Product\") {\n    throw \"impossible\";\n  }\n  const serializeRow = AlgebraicType.makeSerializer(rowType, typespace);\n  const deserializeRow = AlgebraicType.makeDeserializer(rowType, typespace);\n  const sequences = table2.sequences.map((seq) => {\n    const col = rowType.value.elements[seq.column];\n    const colType = col.algebraicType;\n    let sequenceTrigger;\n    switch (colType.tag) {\n      case \"U8\":\n      case \"I8\":\n      case \"U16\":\n      case \"I16\":\n      case \"U32\":\n      case \"I32\":\n        sequenceTrigger = 0;\n        break;\n      case \"U64\":\n      case \"I64\":\n      case \"U128\":\n      case \"I128\":\n      case \"U256\":\n      case \"I256\":\n        sequenceTrigger = 0n;\n        break;\n      default:\n        throw new TypeError(\"invalid sequence type\");\n    }\n    return {\n      colName: col.name,\n      sequenceTrigger,\n      deserialize: AlgebraicType.makeDeserializer(colType, typespace)\n    };\n  });\n  const hasAutoIncrement = sequences.length > 0;\n  const iter = () => tableIterator(sys.datastore_table_scan_bsatn(table_id), deserializeRow);\n  const integrateGeneratedColumns = hasAutoIncrement ? (row, ret_buf) => {\n    BINARY_READER.reset(ret_buf);\n    for (const { colName, deserialize, sequenceTrigger } of sequences) {\n      if (row[colName] === sequenceTrigger) {\n        row[colName] = deserialize(BINARY_READER);\n      }\n    }\n  } : null;\n  const tableMethods = {\n    count: () => sys.datastore_table_row_count(table_id),\n    iter,\n    [Symbol.iterator]: () => iter(),\n    insert: (row) => {\n      const buf = LEAF_BUF;\n      BINARY_WRITER.reset(buf);\n      serializeRow(BINARY_WRITER, row);\n      sys.datastore_insert_bsatn(table_id, buf.buffer, BINARY_WRITER.offset);\n      const ret = { ...row };\n      integrateGeneratedColumns?.(ret, buf.view);\n      return ret;\n    },\n    delete: (row) => {\n      const buf = LEAF_BUF;\n      BINARY_WRITER.reset(buf);\n      BINARY_WRITER.writeU32(1);\n      serializeRow(BINARY_WRITER, row);\n      const count = sys.datastore_delete_all_by_eq_bsatn(\n        table_id,\n        buf.buffer,\n        BINARY_WRITER.offset\n      );\n      return count > 0;\n    }\n  };\n  const tableView = Object.assign(\n    /* @__PURE__ */ Object.create(null),\n    tableMethods\n  );\n  for (const indexDef of table2.indexes) {\n    const accessorName = indexDef.accessorName;\n    const index_id = sys.index_id_from_name(indexDef.sourceName);\n    let column_ids;\n    let isHashIndex = false;\n    switch (indexDef.algorithm.tag) {\n      case \"Hash\":\n        isHashIndex = true;\n        column_ids = indexDef.algorithm.value;\n        break;\n      case \"BTree\":\n        column_ids = indexDef.algorithm.value;\n        break;\n      case \"Direct\":\n        column_ids = [indexDef.algorithm.value];\n        break;\n    }\n    const numColumns = column_ids.length;\n    const columnSet = new Set(column_ids);\n    const isUnique = table2.constraints.filter((x) => x.data.tag === \"Unique\").some((x) => columnSet.isSubsetOf(new Set(x.data.value.columns)));\n    const isPrimaryKey = isUnique && column_ids.length === table2.primaryKey.length && column_ids.every((id, i) => table2.primaryKey[i] === id);\n    const indexSerializers = column_ids.map(\n      (id) => AlgebraicType.makeSerializer(\n        rowType.value.elements[id].algebraicType,\n        typespace\n      )\n    );\n    const serializePoint = (buffer, colVal) => {\n      BINARY_WRITER.reset(buffer);\n      for (let i = 0; i < numColumns; i++) {\n        indexSerializers[i](BINARY_WRITER, colVal[i]);\n      }\n      return BINARY_WRITER.offset;\n    };\n    const serializeSingleElement = numColumns === 1 ? indexSerializers[0] : null;\n    const serializeSinglePoint = serializeSingleElement && ((buffer, colVal) => {\n      BINARY_WRITER.reset(buffer);\n      serializeSingleElement(BINARY_WRITER, colVal);\n      return BINARY_WRITER.offset;\n    });\n    let index;\n    if (isUnique && serializeSinglePoint) {\n      const base = {\n        find: (colVal) => {\n          const buf = LEAF_BUF;\n          const point_len = serializeSinglePoint(buf, colVal);\n          const iter_id = sys.datastore_index_scan_point_bsatn(\n            index_id,\n            buf.buffer,\n            point_len\n          );\n          return tableIterateOne(iter_id, deserializeRow);\n        },\n        delete: (colVal) => {\n          const buf = LEAF_BUF;\n          const point_len = serializeSinglePoint(buf, colVal);\n          const num = sys.datastore_delete_by_index_scan_point_bsatn(\n            index_id,\n            buf.buffer,\n            point_len\n          );\n          return num > 0;\n        }\n      };\n      if (isPrimaryKey) {\n        base.update = (row) => {\n          const buf = LEAF_BUF;\n          BINARY_WRITER.reset(buf);\n          serializeRow(BINARY_WRITER, row);\n          sys.datastore_update_bsatn(\n            table_id,\n            index_id,\n            buf.buffer,\n            BINARY_WRITER.offset\n          );\n          integrateGeneratedColumns?.(row, buf.view);\n          return row;\n        };\n      }\n      index = base;\n    } else if (isUnique) {\n      const base = {\n        find: (colVal) => {\n          if (colVal.length !== numColumns) {\n            throw new TypeError(\"wrong number of elements\");\n          }\n          const buf = LEAF_BUF;\n          const point_len = serializePoint(buf, colVal);\n          const iter_id = sys.datastore_index_scan_point_bsatn(\n            index_id,\n            buf.buffer,\n            point_len\n          );\n          return tableIterateOne(iter_id, deserializeRow);\n        },\n        delete: (colVal) => {\n          if (colVal.length !== numColumns)\n            throw new TypeError(\"wrong number of elements\");\n          const buf = LEAF_BUF;\n          const point_len = serializePoint(buf, colVal);\n          const num = sys.datastore_delete_by_index_scan_point_bsatn(\n            index_id,\n            buf.buffer,\n            point_len\n          );\n          return num > 0;\n        }\n      };\n      if (isPrimaryKey) {\n        base.update = (row) => {\n          const buf = LEAF_BUF;\n          BINARY_WRITER.reset(buf);\n          serializeRow(BINARY_WRITER, row);\n          sys.datastore_update_bsatn(\n            table_id,\n            index_id,\n            buf.buffer,\n            BINARY_WRITER.offset\n          );\n          integrateGeneratedColumns?.(row, buf.view);\n          return row;\n        };\n      }\n      index = base;\n    } else if (serializeSinglePoint) {\n      const rawIndex = {\n        filter: (range) => {\n          const buf = LEAF_BUF;\n          const point_len = serializeSinglePoint(buf, range);\n          const iter_id = sys.datastore_index_scan_point_bsatn(\n            index_id,\n            buf.buffer,\n            point_len\n          );\n          return tableIterator(iter_id, deserializeRow);\n        },\n        delete: (range) => {\n          const buf = LEAF_BUF;\n          const point_len = serializeSinglePoint(buf, range);\n          return sys.datastore_delete_by_index_scan_point_bsatn(\n            index_id,\n            buf.buffer,\n            point_len\n          );\n        }\n      };\n      if (isHashIndex) {\n        index = rawIndex;\n      } else {\n        index = rawIndex;\n      }\n    } else if (isHashIndex) {\n      index = {\n        filter: (range) => {\n          const buf = LEAF_BUF;\n          const point_len = serializePoint(buf, range);\n          const iter_id = sys.datastore_index_scan_point_bsatn(\n            index_id,\n            buf.buffer,\n            point_len\n          );\n          return tableIterator(iter_id, deserializeRow);\n        },\n        delete: (range) => {\n          const buf = LEAF_BUF;\n          const point_len = serializePoint(buf, range);\n          return sys.datastore_delete_by_index_scan_point_bsatn(\n            index_id,\n            buf.buffer,\n            point_len\n          );\n        }\n      };\n    } else {\n      const serializeRange = (buffer, range) => {\n        if (range.length > numColumns) throw new TypeError(\"too many elements\");\n        BINARY_WRITER.reset(buffer);\n        const writer = BINARY_WRITER;\n        const prefix_elems = range.length - 1;\n        for (let i = 0; i < prefix_elems; i++) {\n          indexSerializers[i](writer, range[i]);\n        }\n        const rstartOffset = writer.offset;\n        const term = range[range.length - 1];\n        const serializeTerm = indexSerializers[range.length - 1];\n        if (term instanceof Range) {\n          const writeBound = (bound) => {\n            const tags = { included: 0, excluded: 1, unbounded: 2 };\n            writer.writeU8(tags[bound.tag]);\n            if (bound.tag !== \"unbounded\") serializeTerm(writer, bound.value);\n          };\n          writeBound(term.from);\n          const rstartLen = writer.offset - rstartOffset;\n          writeBound(term.to);\n          const rendLen = writer.offset - rstartLen;\n          return [rstartOffset, prefix_elems, rstartLen, rendLen];\n        } else {\n          writer.writeU8(0);\n          serializeTerm(writer, term);\n          const rstartLen = writer.offset;\n          const rendLen = 0;\n          return [rstartOffset, prefix_elems, rstartLen, rendLen];\n        }\n      };\n      index = {\n        filter: (range) => {\n          if (range.length === numColumns) {\n            const buf = LEAF_BUF;\n            const point_len = serializePoint(buf, range);\n            const iter_id = sys.datastore_index_scan_point_bsatn(\n              index_id,\n              buf.buffer,\n              point_len\n            );\n            return tableIterator(iter_id, deserializeRow);\n          } else {\n            const buf = LEAF_BUF;\n            const args = serializeRange(buf, range);\n            const iter_id = sys.datastore_index_scan_range_bsatn(\n              index_id,\n              buf.buffer,\n              ...args\n            );\n            return tableIterator(iter_id, deserializeRow);\n          }\n        },\n        delete: (range) => {\n          if (range.length === numColumns) {\n            const buf = LEAF_BUF;\n            const point_len = serializePoint(buf, range);\n            return sys.datastore_delete_by_index_scan_point_bsatn(\n              index_id,\n              buf.buffer,\n              point_len\n            );\n          } else {\n            const buf = LEAF_BUF;\n            const args = serializeRange(buf, range);\n            return sys.datastore_delete_by_index_scan_range_bsatn(\n              index_id,\n              buf.buffer,\n              ...args\n            );\n          }\n        }\n      };\n    }\n    if (Object.hasOwn(tableView, accessorName)) {\n      freeze(Object.assign(tableView[accessorName], index));\n    } else {\n      tableView[accessorName] = freeze(index);\n    }\n  }\n  return freeze(tableView);\n}\nfunction* tableIterator(id, deserialize) {\n  using iter = new IteratorHandle(id);\n  const iterBuf = takeBuf();\n  try {\n    let amt;\n    while (amt = iter.advance(iterBuf)) {\n      const reader = new BinaryReader(iterBuf.view);\n      while (reader.offset < amt) {\n        yield deserialize(reader);\n      }\n    }\n  } finally {\n    returnBuf(iterBuf);\n  }\n}\nfunction tableIterateOne(id, deserialize) {\n  const buf = LEAF_BUF;\n  const ret = advanceIterRaw(id, buf);\n  if (ret !== 0) {\n    BINARY_READER.reset(buf.view);\n    return deserialize(BINARY_READER);\n  }\n  return null;\n}\nfunction advanceIterRaw(id, buf) {\n  while (true) {\n    try {\n      return 0 | sys.row_iter_bsatn_advance(id, buf.buffer);\n    } catch (e) {\n      if (e && typeof e === \"object\" && hasOwn(e, \"__buffer_too_small__\")) {\n        buf.grow(e.__buffer_too_small__);\n        continue;\n      }\n      throw e;\n    }\n  }\n}\nvar DEFAULT_BUFFER_CAPACITY = 32 * 1024 * 2;\nvar ITER_BUFS = [\n  new ResizableBuffer(DEFAULT_BUFFER_CAPACITY)\n];\nvar ITER_BUF_COUNT = 1;\nfunction takeBuf() {\n  return ITER_BUF_COUNT ? ITER_BUFS[--ITER_BUF_COUNT] : new ResizableBuffer(DEFAULT_BUFFER_CAPACITY);\n}\nfunction returnBuf(buf) {\n  ITER_BUFS[ITER_BUF_COUNT++] = buf;\n}\nvar LEAF_BUF = new ResizableBuffer(DEFAULT_BUFFER_CAPACITY);\nvar IteratorHandle = class _IteratorHandle {\n  #id;\n  static #finalizationRegistry = new FinalizationRegistry(\n    sys.row_iter_bsatn_close\n  );\n  constructor(id) {\n    this.#id = id;\n    _IteratorHandle.#finalizationRegistry.register(this, id, this);\n  }\n  /** Unregister this object with the finalization registry and return the id */\n  #detach() {\n    const id = this.#id;\n    this.#id = -1;\n    _IteratorHandle.#finalizationRegistry.unregister(this);\n    return id;\n  }\n  /** Call `row_iter_bsatn_advance`, returning 0 if this iterator has been exhausted. */\n  advance(buf) {\n    if (this.#id === -1) return 0;\n    const ret = advanceIterRaw(this.#id, buf);\n    if (ret <= 0) this.#detach();\n    return ret < 0 ? -ret : ret;\n  }\n  [Symbol.dispose]() {\n    if (this.#id >= 0) {\n      const id = this.#detach();\n      sys.row_iter_bsatn_close(id);\n    }\n  }\n};\n\n// src/server/http_internal.ts\nvar { freeze: freeze2 } = Object;\nvar textEncoder = new TextEncoder();\nvar textDecoder = new TextDecoder(\n  \"utf-8\"\n  /* { fatal: true } */\n);\nvar makeResponse = Symbol(\"makeResponse\");\nvar SyncResponse = class _SyncResponse {\n  #body;\n  #inner;\n  constructor(body, init) {\n    if (body == null) {\n      this.#body = null;\n    } else if (typeof body === \"string\") {\n      this.#body = body;\n    } else {\n      this.#body = new Uint8Array(body).buffer;\n    }\n    this.#inner = {\n      headers: new Headers(init?.headers),\n      status: init?.status ?? 200,\n      statusText: init?.statusText ?? \"\",\n      type: \"default\",\n      url: null,\n      aborted: false\n    };\n  }\n  static [makeResponse](body, inner) {\n    const me = new _SyncResponse(body);\n    me.#inner = inner;\n    return me;\n  }\n  get headers() {\n    return this.#inner.headers;\n  }\n  get status() {\n    return this.#inner.status;\n  }\n  get statusText() {\n    return this.#inner.statusText;\n  }\n  get ok() {\n    return 200 <= this.#inner.status && this.#inner.status <= 299;\n  }\n  get url() {\n    return this.#inner.url ?? \"\";\n  }\n  get type() {\n    return this.#inner.type;\n  }\n  arrayBuffer() {\n    return this.bytes().buffer;\n  }\n  bytes() {\n    if (this.#body == null) {\n      return new Uint8Array();\n    } else if (typeof this.#body === \"string\") {\n      return textEncoder.encode(this.#body);\n    } else {\n      return new Uint8Array(this.#body);\n    }\n  }\n  json() {\n    return JSON.parse(this.text());\n  }\n  text() {\n    if (this.#body == null) {\n      return \"\";\n    } else if (typeof this.#body === \"string\") {\n      return this.#body;\n    } else {\n      return textDecoder.decode(this.#body);\n    }\n  }\n};\nvar requestBaseSize = bsatnBaseSize({ types: [] }, HttpRequest.algebraicType);\nvar methods = /* @__PURE__ */ new Map([\n  [\"GET\", { tag: \"Get\" }],\n  [\"HEAD\", { tag: \"Head\" }],\n  [\"POST\", { tag: \"Post\" }],\n  [\"PUT\", { tag: \"Put\" }],\n  [\"DELETE\", { tag: \"Delete\" }],\n  [\"CONNECT\", { tag: \"Connect\" }],\n  [\"OPTIONS\", { tag: \"Options\" }],\n  [\"TRACE\", { tag: \"Trace\" }],\n  [\"PATCH\", { tag: \"Patch\" }]\n]);\nfunction fetch(url, init = {}) {\n  const method = methods.get(init.method?.toUpperCase() ?? \"GET\") ?? {\n    tag: \"Extension\",\n    value: init.method\n  };\n  const headers = {\n    // anys because the typings are wonky - see comment in SyncResponse.constructor\n    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) }))\n  };\n  const uri = \"\" + url;\n  const request = freeze2({\n    method,\n    headers,\n    timeout: init.timeout,\n    uri,\n    version: { tag: \"Http11\" }\n  });\n  const requestBuf = new BinaryWriter(requestBaseSize);\n  HttpRequest.serialize(requestBuf, request);\n  const body = init.body == null ? new Uint8Array() : typeof init.body === \"string\" ? init.body : new Uint8Array(init.body);\n  const [responseBuf, responseBody] = sys.procedure_http_request(\n    requestBuf.getBuffer(),\n    body\n  );\n  const response = HttpResponse.deserialize(new BinaryReader(responseBuf));\n  return SyncResponse[makeResponse](responseBody, {\n    type: \"basic\",\n    url: uri,\n    status: response.code,\n    statusText: (0, import_statuses.default)(response.code),\n    headers: new Headers(),\n    aborted: false\n  });\n}\nfreeze2(fetch);\nvar httpClient = freeze2({ fetch });\n\n// src/server/procedures.ts\nfunction makeProcedureExport(ctx, opts, params, ret, fn) {\n  const name = opts?.name;\n  const procedureExport = (...args) => fn(...args);\n  procedureExport[exportContext] = ctx;\n  procedureExport[registerExport] = (ctx2, exportName) => {\n    registerProcedure(ctx2, name ?? exportName, params, ret, fn);\n    ctx2.functionExports.set(\n      procedureExport,\n      name ?? exportName\n    );\n  };\n  return procedureExport;\n}\nvar TransactionCtxImpl = class TransactionCtx extends ReducerCtxImpl {\n};\nfunction registerProcedure(ctx, exportName, params, ret, fn, opts) {\n  ctx.defineFunction(exportName);\n  const paramsType = {\n    elements: Object.entries(params).map(([n, c]) => ({\n      name: n,\n      algebraicType: ctx.registerTypesRecursively(\n        \"typeBuilder\" in c ? c.typeBuilder : c\n      ).algebraicType\n    }))\n  };\n  const returnType = ctx.registerTypesRecursively(ret).algebraicType;\n  ctx.moduleDef.procedures.push({\n    sourceName: exportName,\n    params: paramsType,\n    returnType,\n    visibility: FunctionVisibility.ClientCallable\n  });\n  const { typespace } = ctx;\n  ctx.procedures.push({\n    fn,\n    deserializeArgs: ProductType.makeDeserializer(paramsType, typespace),\n    serializeReturn: AlgebraicType.makeSerializer(returnType, typespace),\n    returnTypeBaseSize: bsatnBaseSize(typespace, returnType)\n  });\n}\nfunction callProcedure(moduleCtx, id, sender, connectionId, timestamp, argsBuf, dbView) {\n  const { fn, deserializeArgs, serializeReturn, returnTypeBaseSize } = moduleCtx.procedures[id];\n  const args = deserializeArgs(new BinaryReader(argsBuf));\n  const ctx = new ProcedureCtxImpl(\n    sender,\n    timestamp,\n    connectionId,\n    dbView\n  );\n  const ret = callUserFunction(fn, ctx, args);\n  const retBuf = new BinaryWriter(returnTypeBaseSize);\n  serializeReturn(retBuf, ret);\n  return retBuf.getBuffer();\n}\nvar ProcedureCtxImpl = class ProcedureCtx {\n  constructor(sender, timestamp, connectionId, dbView) {\n    this.sender = sender;\n    this.timestamp = timestamp;\n    this.connectionId = connectionId;\n    this.#dbView = dbView;\n  }\n  #identity;\n  #uuidCounter;\n  #random;\n  #dbView;\n  get identity() {\n    return this.#identity ??= new Identity(sys.identity());\n  }\n  get random() {\n    return this.#random ??= makeRandom(this.timestamp);\n  }\n  get http() {\n    return httpClient;\n  }\n  withTx(body) {\n    const run = () => {\n      const timestamp = sys.procedure_start_mut_tx();\n      try {\n        const ctx = new TransactionCtxImpl(\n          this.sender,\n          new Timestamp(timestamp),\n          this.connectionId,\n          this.#dbView()\n        );\n        return body(ctx);\n      } catch (e) {\n        sys.procedure_abort_mut_tx();\n        throw e;\n      }\n    };\n    let res = run();\n    try {\n      sys.procedure_commit_mut_tx();\n      return res;\n    } catch {\n    }\n    console.warn(\"committing anonymous transaction failed\");\n    res = run();\n    try {\n      sys.procedure_commit_mut_tx();\n      return res;\n    } catch (e) {\n      throw new Error(\"transaction retry failed again\", { cause: e });\n    }\n  }\n  newUuidV4() {\n    const bytes = this.random.fill(new Uint8Array(16));\n    return Uuid.fromRandomBytesV4(bytes);\n  }\n  newUuidV7() {\n    const bytes = this.random.fill(new Uint8Array(4));\n    const counter = this.#uuidCounter ??= { value: 0 };\n    return Uuid.fromCounterV7(counter, this.timestamp, bytes);\n  }\n};\n\n// src/server/reducers.ts\nfunction makeReducerExport(ctx, opts, params, fn, lifecycle) {\n  const reducerExport = (...args) => fn(...args);\n  reducerExport[exportContext] = ctx;\n  reducerExport[registerExport] = (ctx2, exportName) => {\n    registerReducer(ctx2, exportName, params, fn, opts, lifecycle);\n    ctx2.functionExports.set(\n      reducerExport,\n      exportName\n    );\n  };\n  return reducerExport;\n}\nfunction registerReducer(ctx, exportName, params, fn, opts, lifecycle) {\n  ctx.defineFunction(exportName);\n  if (!(params instanceof RowBuilder)) {\n    params = new RowBuilder(params);\n  }\n  if (params.typeName === void 0) {\n    params.typeName = toPascalCase(exportName);\n  }\n  const ref = ctx.registerTypesRecursively(params);\n  const paramsType = ctx.resolveType(ref).value;\n  const isLifecycle = lifecycle != null;\n  ctx.moduleDef.reducers.push({\n    sourceName: exportName,\n    params: paramsType,\n    //ModuleDef validation code is responsible to mark private reducers\n    visibility: FunctionVisibility.ClientCallable,\n    //Hardcoded for now - reducers do not return values yet\n    okReturnType: AlgebraicType.Product({ elements: [] }),\n    errReturnType: AlgebraicType.String\n  });\n  if (opts?.name != null) {\n    ctx.moduleDef.explicitNames.entries.push({\n      tag: \"Function\",\n      value: {\n        sourceName: exportName,\n        canonicalName: opts.name\n      }\n    });\n  }\n  if (isLifecycle) {\n    ctx.moduleDef.lifeCycleReducers.push({\n      lifecycleSpec: lifecycle,\n      functionName: exportName\n    });\n  }\n  if (!fn.name) {\n    Object.defineProperty(fn, \"name\", { value: exportName, writable: false });\n  }\n  ctx.reducers.push(fn);\n}\n\n// src/server/schema.ts\nvar SchemaInner = class extends ModuleContext {\n  schemaType;\n  existingFunctions = /* @__PURE__ */ new Set();\n  reducers = [];\n  procedures = [];\n  views = [];\n  anonViews = [];\n  /**\n   * Maps ReducerExport objects to the name of the reducer.\n   * Used for resolving the reducers of scheduled tables.\n   */\n  functionExports = /* @__PURE__ */ new Map();\n  pendingSchedules = [];\n  constructor(getSchemaType) {\n    super();\n    this.schemaType = getSchemaType(this);\n  }\n  defineFunction(name) {\n    if (this.existingFunctions.has(name)) {\n      throw new TypeError(\n        `There is already a reducer or procedure with the name '${name}'`\n      );\n    }\n    this.existingFunctions.add(name);\n  }\n  resolveSchedules() {\n    for (const { reducer, scheduleAtCol, tableName } of this.pendingSchedules) {\n      const functionName = this.functionExports.get(reducer());\n      if (functionName === void 0) {\n        const msg = `Table ${tableName} defines a schedule, but it seems like the associated function was not exported.`;\n        throw new TypeError(msg);\n      }\n      this.moduleDef.schedules.push({\n        sourceName: void 0,\n        tableName,\n        scheduleAtCol,\n        functionName\n      });\n    }\n  }\n};\nvar Schema = class {\n  #ctx;\n  constructor(ctx) {\n    this.#ctx = ctx;\n  }\n  [moduleHooks](exports) {\n    const registeredSchema = this.#ctx;\n    for (const [name, moduleExport] of Object.entries(exports)) {\n      if (name === \"default\") continue;\n      if (!isModuleExport(moduleExport)) {\n        throw new TypeError(\n          \"exporting something that is not a spacetime export\"\n        );\n      }\n      checkExportContext(moduleExport, registeredSchema);\n      moduleExport[registerExport](registeredSchema, name);\n    }\n    registeredSchema.resolveSchedules();\n    return makeHooks(registeredSchema);\n  }\n  get schemaType() {\n    return this.#ctx.schemaType;\n  }\n  get moduleDef() {\n    return this.#ctx.moduleDef;\n  }\n  get typespace() {\n    return this.#ctx.typespace;\n  }\n  reducer(...args) {\n    let opts, params = {}, fn;\n    switch (args.length) {\n      case 1:\n        [fn] = args;\n        break;\n      case 2: {\n        let arg1;\n        [arg1, fn] = args;\n        if (typeof arg1.name === \"string\") opts = arg1;\n        else params = arg1;\n        break;\n      }\n      case 3:\n        [opts, params, fn] = args;\n        break;\n    }\n    return makeReducerExport(this.#ctx, opts, params, fn);\n  }\n  init(...args) {\n    let opts, fn;\n    switch (args.length) {\n      case 1:\n        [fn] = args;\n        break;\n      case 2:\n        [opts, fn] = args;\n        break;\n    }\n    return makeReducerExport(this.#ctx, opts, {}, fn, Lifecycle.Init);\n  }\n  clientConnected(...args) {\n    let opts, fn;\n    switch (args.length) {\n      case 1:\n        [fn] = args;\n        break;\n      case 2:\n        [opts, fn] = args;\n        break;\n    }\n    return makeReducerExport(this.#ctx, opts, {}, fn, Lifecycle.OnConnect);\n  }\n  clientDisconnected(...args) {\n    let opts, fn;\n    switch (args.length) {\n      case 1:\n        [fn] = args;\n        break;\n      case 2:\n        [opts, fn] = args;\n        break;\n    }\n    return makeReducerExport(this.#ctx, opts, {}, fn, Lifecycle.OnDisconnect);\n  }\n  view(opts, ret, fn) {\n    return makeViewExport(this.#ctx, opts, {}, ret, fn);\n  }\n  // TODO: re-enable once parameterized views are supported in SQL\n  // view<Ret extends ViewReturnTypeBuilder>(\n  //   opts: ViewOpts,\n  //   ret: Ret,\n  //   fn: ViewFn<S, {}, Ret>\n  // ): void;\n  // view<Params extends ParamsObj, Ret extends ViewReturnTypeBuilder>(\n  //   opts: ViewOpts,\n  //   params: Params,\n  //   ret: Ret,\n  //   fn: ViewFn<S, {}, Ret>\n  // ): void;\n  // view<Params extends ParamsObj, Ret extends ViewReturnTypeBuilder>(\n  //   opts: ViewOpts,\n  //   paramsOrRet: Ret | Params,\n  //   retOrFn: ViewFn<S, {}, Ret> | Ret,\n  //   maybeFn?: ViewFn<S, Params, Ret>\n  // ): void {\n  //   if (typeof retOrFn === 'function') {\n  //     defineView(name, false, {}, paramsOrRet as Ret, retOrFn);\n  //   } else {\n  //     defineView(name, false, paramsOrRet as Params, retOrFn, maybeFn!);\n  //   }\n  // }\n  anonymousView(opts, ret, fn) {\n    return makeAnonViewExport(this.#ctx, opts, {}, ret, fn);\n  }\n  procedure(...args) {\n    let opts, params = {}, ret, fn;\n    switch (args.length) {\n      case 2:\n        [ret, fn] = args;\n        break;\n      case 3: {\n        let arg1;\n        [arg1, ret, fn] = args;\n        if (typeof arg1.name === \"string\") opts = arg1;\n        else params = arg1;\n        break;\n      }\n      case 4:\n        [opts, params, ret, fn] = args;\n        break;\n    }\n    return makeProcedureExport(this.#ctx, opts, params, ret, fn);\n  }\n  /**\n   * Bundle multiple reducers, procedures, etc into one value to export.\n   * The name they will be exported with is their corresponding key in the `exports` argument.\n   */\n  exportGroup(exports) {\n    return {\n      [exportContext]: this.#ctx,\n      [registerExport](ctx, _exportName) {\n        for (const [exportName, moduleExport] of Object.entries(exports)) {\n          checkExportContext(moduleExport, ctx);\n          moduleExport[registerExport](ctx, exportName);\n        }\n      }\n    };\n  }\n  clientVisibilityFilter = {\n    sql: (filter) => ({\n      [exportContext]: this.#ctx,\n      [registerExport](ctx, _exportName) {\n        ctx.moduleDef.rowLevelSecurity.push({ sql: filter });\n      }\n    })\n  };\n};\nvar registerExport = Symbol(\"SpacetimeDB.registerExport\");\nvar exportContext = Symbol(\"SpacetimeDB.exportContext\");\nfunction isModuleExport(x) {\n  return (typeof x === \"function\" || typeof x === \"object\") && x !== null && registerExport in x;\n}\nfunction checkExportContext(exp, schema2) {\n  if (exp[exportContext] != null && exp[exportContext] !== schema2) {\n    throw new TypeError(\"multiple schemas are not supported\");\n  }\n}\nfunction schema(tables, moduleSettings) {\n  const ctx = new SchemaInner((ctx2) => {\n    if (moduleSettings?.CASE_CONVERSION_POLICY != null) {\n      ctx2.setCaseConversionPolicy(moduleSettings.CASE_CONVERSION_POLICY);\n    }\n    const tableSchemas = {};\n    for (const [accName, table2] of Object.entries(tables)) {\n      const tableDef = table2.tableDef(ctx2, accName);\n      tableSchemas[accName] = tableToSchema(accName, table2, tableDef);\n      ctx2.moduleDef.tables.push(tableDef);\n      if (table2.schedule) {\n        ctx2.pendingSchedules.push({\n          ...table2.schedule,\n          tableName: tableDef.sourceName\n        });\n      }\n      if (table2.tableName) {\n        ctx2.moduleDef.explicitNames.entries.push({\n          tag: \"Table\",\n          value: {\n            sourceName: accName,\n            canonicalName: table2.tableName\n          }\n        });\n      }\n    }\n    return { tables: tableSchemas };\n  });\n  return new Schema(ctx);\n}\n\n// src/server/console.ts\nvar import_object_inspect = __toESM(require_object_inspect());\nvar fmtLog = (...data) => data.map((x) => typeof x === \"string\" ? x : (0, import_object_inspect.default)(x)).join(\" \");\nvar console_level_error = 0;\nvar console_level_warn = 1;\nvar console_level_info = 2;\nvar console_level_debug = 3;\nvar console_level_trace = 4;\nvar timerMap = /* @__PURE__ */ new Map();\nvar console2 = {\n  // @ts-expect-error we want a blank prototype, but typescript complains\n  __proto__: {},\n  [Symbol.toStringTag]: \"console\",\n  assert: (condition = false, ...data) => {\n    if (!condition) {\n      sys.console_log(console_level_error, fmtLog(...data));\n    }\n  },\n  clear: () => {\n  },\n  debug: (...data) => {\n    sys.console_log(console_level_debug, fmtLog(...data));\n  },\n  error: (...data) => {\n    sys.console_log(console_level_error, fmtLog(...data));\n  },\n  info: (...data) => {\n    sys.console_log(console_level_info, fmtLog(...data));\n  },\n  log: (...data) => {\n    sys.console_log(console_level_info, fmtLog(...data));\n  },\n  table: (tabularData, _properties) => {\n    sys.console_log(console_level_info, fmtLog(tabularData));\n  },\n  trace: (...data) => {\n    sys.console_log(console_level_trace, fmtLog(...data));\n  },\n  warn: (...data) => {\n    sys.console_log(console_level_warn, fmtLog(...data));\n  },\n  dir: (_item, _options) => {\n  },\n  dirxml: (..._data) => {\n  },\n  // Counting\n  count: (_label = \"default\") => {\n  },\n  countReset: (_label = \"default\") => {\n  },\n  // Grouping\n  group: (..._data) => {\n  },\n  groupCollapsed: (..._data) => {\n  },\n  groupEnd: () => {\n  },\n  // Timing\n  time: (label = \"default\") => {\n    if (timerMap.has(label)) {\n      sys.console_log(console_level_warn, `Timer '${label}' already exists.`);\n      return;\n    }\n    timerMap.set(label, sys.console_timer_start(label));\n  },\n  timeLog: (label = \"default\", ...data) => {\n    sys.console_log(console_level_info, fmtLog(label, ...data));\n  },\n  timeEnd: (label = \"default\") => {\n    const spanId = timerMap.get(label);\n    if (spanId === void 0) {\n      sys.console_log(console_level_warn, `Timer '${label}' does not exist.`);\n      return;\n    }\n    sys.console_timer_end(spanId);\n    timerMap.delete(label);\n  },\n  // Additional console methods to satisfy the Console interface\n  timeStamp: () => {\n  },\n  profile: () => {\n  },\n  profileEnd: () => {\n  }\n};\n\n// src/server/polyfills.ts\nglobalThis.console = console2;\n/*! Bundled license information:\n\nstatuses/index.js:\n  (*!\n   * statuses\n   * Copyright(c) 2014 Jonathan Ong\n   * Copyright(c) 2016 Douglas Christopher Wilson\n   * MIT Licensed\n   *)\n*/\n\nexport { 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 };\n//# sourceMappingURL=index.mjs.map\n//# sourceMappingURL=index.mjs.map","import { schema, t, table, SenderError } from 'spacetimedb/server';\n\nconst channel_kind = t.enum('ChannelKind', { text: t.unit(), voice: t.unit() });\n\nconst user = table(\n  {\n    name: 'user',\n    public: true,\n  },\n  {\n    identity: t.identity().primaryKey(),\n    name: t.string().optional(),\n    online: t.bool(),\n    issuer: t.string().optional(),\n    subject: t.string().optional(),\n    username: t.string().optional(), // For creds-based auth\n    password: t.string().optional(), // For creds-based auth (Note: plain text for MVP)\n  }\n);\n\nconst server = table(\n  { name: 'server', public: true },\n  {\n    id: t.u64().primaryKey().autoInc(),\n    name: t.string(),\n    owner: t.identity().optional(),\n  }\n);\n\nconst channel = table(\n  {\n    name: 'channel',\n    public: true,\n    indexes: [\n      { accessor: 'by_server_id', algorithm: 'btree', columns: ['server_id'] }\n    ]\n  },\n  {\n    id: t.u64().primaryKey().autoInc(),\n    server_id: t.u64(),\n    name: t.string(),\n    kind: channel_kind,\n  }\n);\n\nconst voice_state = table(\n  {\n    name: 'voice_state',\n    public: true,\n    indexes: [\n      { accessor: 'by_channel_id', algorithm: 'btree', columns: ['channel_id'] }\n    ]\n  },\n  {\n    identity: t.identity().primaryKey(),\n    channel_id: t.u64(),\n  }\n);\n\nconst sdp_offer = table(\n  {\n    name: 'sdp_offer',\n    public: true,\n    indexes: [\n      { accessor: 'by_receiver', algorithm: 'btree', columns: ['receiver'] }\n    ]\n  },\n  {\n    sender: t.identity(),\n    receiver: t.identity(),\n    sdp: t.string(),\n    channel_id: t.u64(),\n  }\n);\n\nconst sdp_answer = table(\n  {\n    name: 'sdp_answer',\n    public: true,\n    indexes: [\n      { accessor: 'by_receiver', algorithm: 'btree', columns: ['receiver'] }\n    ]\n  },\n  {\n    sender: t.identity(),\n    receiver: t.identity(),\n    sdp: t.string(),\n    channel_id: t.u64(),\n  }\n);\n\nconst ice_candidate = table(\n  {\n    name: 'ice_candidate',\n    public: true,\n    indexes: [\n      { accessor: 'by_receiver', algorithm: 'btree', columns: ['receiver'] }\n    ]\n  },\n  {\n    sender: t.identity(),\n    receiver: t.identity(),\n    candidate: t.string(),\n    channel_id: t.u64(),\n  }\n);\n\nconst thread = table(\n  {\n    name: 'thread',\n    public: true,\n    indexes: [\n      { accessor: 'by_channel_id', algorithm: 'btree', columns: ['channel_id'] }\n    ]\n  },\n  {\n    id: t.u64().primaryKey().autoInc(),\n    channel_id: t.u64(),\n    parent_message_id: t.u64().unique(),\n    name: t.string(),\n  }\n);\n\nconst message = table(\n  {\n    name: 'message',\n    public: true,\n    indexes: [\n      { accessor: 'by_channel_id', algorithm: 'btree', columns: ['channel_id'] },\n      { accessor: 'by_thread_id', algorithm: 'btree', columns: ['thread_id'] }\n    ]\n  },\n  {\n    id: t.u64().primaryKey().autoInc(),\n    sender: t.identity(),\n    sent: t.timestamp(),\n    text: t.string(),\n    channel_id: t.u64(),\n    thread_id: t.u64().optional(),\n  }\n);\n\nconst spacetimedb = schema({ user, server, channel, voice_state, sdp_offer, sdp_answer, ice_candidate, thread, message });\nexport default spacetimedb;\n\nfunction validateName(name: string) {\n  if (!name || name.trim().length === 0) throw new SenderError('Names must not be empty');\n}\n\nexport const set_name = spacetimedb.reducer(\n  { name: t.string() },\n  (ctx, { name }) => {\n    validateName(name);\n    const user = ctx.db.user.identity.find(ctx.sender);\n    if (!user) throw new SenderError('Cannot set name for unknown user');\n    ctx.db.user.identity.update({ ...user, name });\n  }\n);\n\nexport const register = spacetimedb.reducer(\n  { username: t.string(), password: t.string() },\n  (ctx, { username, password }) => {\n    validateName(username);\n    if (!password || password.length < 4) throw new SenderError('Password must be at least 4 characters');\n    \n    for (const u of ctx.db.user.iter()) {\n      if (u.username === username) {\n        throw new SenderError('Username already taken');\n      }\n    }\n\n    const user = ctx.db.user.identity.find(ctx.sender);\n    if (user) {\n      ctx.db.user.identity.update({ \n        ...user, \n        username, \n        password,\n        name: user.name || username \n      });\n    } else {\n      ctx.db.user.insert({\n        identity: ctx.sender,\n        username,\n        password,\n        name: username,\n        online: true,\n        issuer: undefined,\n        subject: undefined\n      });\n    }\n  }\n);\n\nexport const login = spacetimedb.reducer(\n  { username: t.string(), password: t.string() },\n  (ctx, { username, password }) => {\n    let foundUser = null;\n    for (const u of ctx.db.user.iter()) {\n      if (u.username === username && u.password === password) {\n        foundUser = u;\n        break;\n      }\n    }\n\n    if (!foundUser) {\n      throw new SenderError('Invalid username or password');\n    }\n\n    const currentIdentityUser = ctx.db.user.identity.find(ctx.sender);\n    if (currentIdentityUser && currentIdentityUser.identity.toHexString() !== foundUser.identity.toHexString()) {\n       ctx.db.user.identity.delete(ctx.sender);\n    }\n\n    if (foundUser.identity.toHexString() !== ctx.sender.toHexString()) {\n      ctx.db.user.identity.delete(foundUser.identity);\n      ctx.db.user.insert({\n        ...foundUser,\n        identity: ctx.sender,\n        online: true\n      });\n    } else {\n      ctx.db.user.identity.update({\n        ...foundUser,\n        online: true\n      });\n    }\n  }\n);\n\nexport const create_server = spacetimedb.reducer(\n  { name: t.string() },\n  (ctx, { name }) => {\n    validateName(name);\n    const user = ctx.db.user.identity.find(ctx.sender);\n    if (!user || (!user.username && !user.subject)) {\n      throw new SenderError('You must be logged in to create a server');\n    }\n    const s = ctx.db.server.insert({ id: 0n, name, owner: ctx.sender });\n    ctx.db.channel.insert({ id: 0n, server_id: s.id, name: 'general', kind: { tag: 'text' } });\n    ctx.db.channel.insert({ id: 0n, server_id: s.id, name: 'Voice General', kind: { tag: 'voice' } });\n  }\n);\n\nexport const create_channel = spacetimedb.reducer(\n  { name: t.string(), serverId: t.u64(), isVoice: t.bool() },\n  (ctx, { name, serverId, isVoice }) => {\n    validateName(name);\n    const user = ctx.db.user.identity.find(ctx.sender);\n    if (!user || (!user.username && !user.subject)) {\n      throw new SenderError('You must be logged in to create a channel');\n    }\n    const s = ctx.db.server.id.find(serverId);\n    if (!s) throw new SenderError('Server not found');\n    ctx.db.channel.insert({ \n      id: 0n, \n      server_id: serverId, \n      name, \n      kind: isVoice ? { tag: 'voice' } : { tag: 'text' } \n    });\n  }\n);\n\nexport const join_voice = spacetimedb.reducer(\n  { channelId: t.u64() },\n  (ctx, { channelId }) => {\n    const user = ctx.db.user.identity.find(ctx.sender);\n    if (!user || (!user.username && !user.subject)) {\n      throw new SenderError('You must be logged in to join voice');\n    }\n    const chan = ctx.db.channel.id.find(channelId);\n    if (!chan || chan.kind.tag !== 'voice') throw new SenderError('Invalid voice channel');\n    \n    const existing = ctx.db.voice_state.identity.find(ctx.sender);\n    if (existing) {\n      if (existing.channel_id !== channelId) {\n        clearSignalingForUser(ctx, ctx.sender);\n        ctx.db.voice_state.identity.update({ identity: ctx.sender, channel_id: channelId });\n      }\n    } else {\n      ctx.db.voice_state.insert({ identity: ctx.sender, channel_id: channelId });\n    }\n  }\n);\n\nexport const leave_voice = spacetimedb.reducer((ctx) => {\n  ctx.db.voice_state.identity.delete(ctx.sender);\n  clearSignalingForUser(ctx, ctx.sender);\n});\n\nexport const send_sdp_offer = spacetimedb.reducer(\n  { receiver: t.identity(), sdp: t.string(), channelId: t.u64() },\n  (ctx, { receiver, sdp, channelId }) => {\n    ctx.db.sdp_offer.insert({ sender: ctx.sender, receiver, sdp, channel_id: channelId });\n  }\n);\n\nexport const send_sdp_answer = spacetimedb.reducer(\n  { receiver: t.identity(), sdp: t.string(), channelId: t.u64() },\n  (ctx, { receiver, sdp, channelId }) => {\n    ctx.db.sdp_answer.insert({ sender: ctx.sender, receiver, sdp, channel_id: channelId });\n  }\n);\n\nexport const send_ice_candidate = spacetimedb.reducer(\n  { receiver: t.identity(), candidate: t.string(), channelId: t.u64() },\n  (ctx, { receiver, candidate, channelId }) => {\n    ctx.db.ice_candidate.insert({ sender: ctx.sender, receiver, candidate, channel_id: channelId });\n  }\n);\n\nfunction clearSignalingForUser(ctx: any, identity: any) {\n  // Clean up stale signaling messages for the user\n  // Note: Iterating and deleting might not be the most performant for large tables.\n  // In a production scenario, consider TTLs or more targeted deletion strategies.\n\n  const userOffers = ctx.db.sdp_offer.iter().filter((offer: any) => \n    offer.sender.isEqual(identity) || offer.receiver.isEqual(identity)\n  );\n  for (const offer of userOffers) {\n    ctx.db.sdp_offer.delete(offer.id); // Assuming 'id' is the primary key\n  }\n\n  const userAnswers = ctx.db.sdp_answer.iter().filter((answer: any) => \n    answer.sender.isEqual(identity) || answer.receiver.isEqual(identity)\n  );\n  for (const answer of userAnswers) {\n    ctx.db.sdp_answer.delete(answer.id); // Assuming 'id' is the primary key\n  }\n\n  const userCandidates = ctx.db.ice_candidate.iter().filter((candidate: any) => \n    candidate.sender.isEqual(identity) || candidate.receiver.isEqual(identity)\n  );\n  for (const candidate of userCandidates) {\n    ctx.db.ice_candidate.delete(candidate.id); // Assuming 'id' is the primary key\n  }\n}\n\nexport const create_thread = spacetimedb.reducer(\n  { name: t.string(), channelId: t.u64(), parentMessageId: t.u64() },\n  (ctx, { name, channelId, parentMessageId }) => {\n    validateName(name);\n    const user = ctx.db.user.identity.find(ctx.sender);\n    if (!user || (!user.username && !user.subject)) {\n      throw new SenderError('You must be logged in to create a thread');\n    }\n    const parentMsg = ctx.db.message.id.find(parentMessageId);\n    if (!parentMsg) throw new SenderError('Parent message not found');\n    \n    ctx.db.thread.insert({ id: 0n, channel_id: channelId, parent_message_id: parentMessageId, name });\n  }\n);\n\nexport const send_message = spacetimedb.reducer(\n  { text: t.string(), channelId: t.u64(), threadId: t.u64().optional() },\n  (ctx, { text, channelId, threadId }) => {\n    if (!text || text.trim().length === 0) throw new SenderError('Messages must not be empty');\n    \n    const user = ctx.db.user.identity.find(ctx.sender);\n    if (!user || (!user.username && !user.subject)) {\n      throw new SenderError('You must be logged in to send messages');\n    }\n\n    ctx.db.message.insert({\n      id: 0n,\n      sender: ctx.sender,\n      text,\n      sent: ctx.timestamp,\n      channel_id: channelId,\n      thread_id: threadId,\n    });\n  }\n);\n\nexport const init = spacetimedb.init(ctx => {\n  let hasServers = false;\n  for (const _ of ctx.db.server.iter()) {\n    hasServers = true;\n    break;\n  }\n  if (!hasServers) {\n    const s = ctx.db.server.insert({ id: 0n, name: 'Spacetime Community', owner: undefined });\n    ctx.db.channel.insert({ id: 0n, server_id: s.id, name: 'general', kind: { tag: 'text' } });\n    ctx.db.channel.insert({ id: 0n, server_id: s.id, name: 'Voice General', kind: { tag: 'voice' } });\n  }\n});\n\nexport const onConnect = spacetimedb.clientConnected(ctx => {\n  const user = ctx.db.user.identity.find(ctx.sender);\n  \n  if (ctx.senderAuth.hasJWT && ctx.senderAuth.jwt) {\n    const jwt = ctx.senderAuth.jwt;\n    const issuer = jwt.issuer;\n    const subject = jwt.subject;\n    const payload = jwt.fullPayload;\n    const name = (payload.name as string) || (payload.nickname as string) || (payload.preferred_username as string) || (payload.email as string);\n\n    if (user) {\n      ctx.db.user.identity.update({ \n        ...user, \n        online: true,\n        name: user.name || name,\n        issuer,\n        subject\n      });\n    } else {\n      ctx.db.user.insert({\n        name,\n        identity: ctx.sender,\n        online: true,\n        issuer,\n        subject,\n        username: undefined,\n        password: undefined\n      });\n    }\n  } else if (user) {\n    ctx.db.user.identity.update({ ...user, online: true });\n  }\n});\n\nexport const onDisconnect = spacetimedb.clientDisconnected(ctx => {\n  const user = ctx.db.user.identity.find(ctx.sender);\n  if (user) {\n    ctx.db.user.identity.update({ ...user, online: false });\n  }\n  // Auto-leave voice on disconnect\n  ctx.db.voice_state.identity.delete(ctx.sender);\n  // Clean up signaling messages associated with the disconnected user\n  clearSignalingForUser(ctx, ctx.sender);\n});\n"],"mappings":"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","debugId":"c9a38ab5-d5c5-4af9-81c8-7086063e3faf"}
|