monoidentity 0.7.0 → 0.8.0

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export { getLoginRecognized, getStorage } from "./storage.js";
+export { getLoginRecognized, getVerification, retrieveVerification, useVerification, getStorage, } from "./storage.js";
 export { trackReady } from "./trackready.js";
 export { encode, decode } from "./utils-base36.js";

package/dist/index.js

@@ -1,3 +1,3 @@
-export { getLoginRecognized, getStorage } from "./storage.js";
+export { getLoginRecognized, getVerification, retrieveVerification, useVerification, getStorage, } from "./storage.js";
 export { trackReady } from "./trackready.js";
 export { encode, decode } from "./utils-base36.js";

package/dist/{_replay.d.ts → storage/_replay.d.ts}

@@ -1,4 +1,4 @@
-import type { Dict } from "./_createstore.js";
+import type { Dict } from "./createstore.js";
 type Modification = {
     type: "set";
     old?: string;

package/dist/{_replay.js → storage/_replay.js}

@@ -1,4 +1,4 @@
-import { throttle } from "./utils-timing.js";
+import { throttle } from "./_timing.js";
 export const wrapWithReplay = (storage) => {
     let modifications = {};
     if (localStorage["monoidentity-x/backup/modifications"]) {

package/dist/{_localstorage.d.ts → storage/localstorage.d.ts}

@@ -1,3 +1,3 @@
-import { type Dict } from "./_createstore.js";
+import { type Dict } from "./createstore.js";
 export declare const init: () => Record<string, string>;
 export declare const wrapWithBackup: (storage: Dict, requestBackup: (startBackup: () => void) => void) => Dict;

package/dist/{_localstorage.js → storage/localstorage.js}

@@ -1,6 +1,6 @@
-import { createStore } from "./_createstore.js";
+import { createStore } from "./createstore.js";
 import { wrapWithReplay } from "./_replay.js";
-import { canBackup } from "./utils-transport.js";
+import { canBackup } from "../utils-transport.js";
 import { openDB } from "idb";
 const prefix = "monoidentity/";
 const prefixed = (key) => `${prefix}${key}`;

package/dist/storage.d.ts

@@ -1,5 +1,11 @@
-import type { Login } from "./utils-transport.js";
 export declare const setup: (i: Record<string, string>, a: string) => void;
 export declare const LOGIN_RECOGNIZED_PATH = ".core/login.encjson";
-export declare const getLoginRecognized: () => Login;
+export declare const getLoginRecognized: () => {
+    email: string;
+    password: string;
+};
+export declare const VERIFICATION_PATH = ".core/verification.jwt";
+export declare const getVerification: () => Promise<string>;
+export declare const retrieveVerification: () => Promise<any>;
+export declare const useVerification: (jwt: string) => Promise<import("@tsndr/cloudflare-worker-jwt").JwtData<{}, {}> | undefined>;
 export declare const getStorage: (realm: "config" | "cache") => Record<string, any>;

package/dist/storage.js

@@ -1,6 +1,11 @@
 import { stringify, parse } from "devalue";
-import { decode } from "./utils-base36.js";
-import { createStore } from "./_createstore.js";
+import { parse as useSchema } from "valibot";
+import { decode, encode } from "./utils-base36.js";
+import { createStore } from "./storage/createstore.js";
+import { login as loginSchema } from "./utils-transport.js";
+import { verify } from "@tsndr/cloudflare-worker-jwt";
+import publicKey from "./verification/public-key.js";
+import attest from "./verification/attest-remote.js";
 let implementation;
 let app = "";
 export const setup = (i, a) => {
@@ -14,8 +19,32 @@ export const getLoginRecognized = () => {
     const login = implementation[LOGIN_RECOGNIZED_PATH];
     if (!login)
         throw new Error("No login found");
-    return JSON.parse(decode(login));
+    return useSchema(loginSchema, JSON.parse(decode(login)));
 };
+export const VERIFICATION_PATH = ".core/verification.jwt";
+export const getVerification = async () => {
+    if (!implementation)
+        throw new Error("No implementation set");
+    const jwt = implementation[VERIFICATION_PATH];
+    if (!jwt)
+        throw new Error("No verification found");
+    await verify(jwt, publicKey, { algorithm: "ES256", throwError: true });
+    return jwt;
+};
+export const retrieveVerification = async () => {
+    if (!implementation)
+        throw new Error("No implementation set");
+    let jwt;
+    try {
+        jwt = await getVerification();
+    }
+    catch {
+        jwt = await attest(encode(JSON.stringify(getLoginRecognized())));
+        implementation[VERIFICATION_PATH] = jwt;
+    }
+    return jwt;
+};
+export const useVerification = (jwt) => verify(jwt, publicKey, { algorithm: "ES256", throwError: true });
 export const getStorage = (realm) => {
     const prefix = (text) => `.${realm}/${app}/${text}.devalue`;
     if (!app)

package/dist/trackready.js

@@ -1,5 +1,5 @@
 import {} from "./utils-transport.js";
-import { init as initLocal, wrapWithBackup } from "./_localstorage.js";
+import { init as initLocal, wrapWithBackup } from "./storage/localstorage.js";
 import { LOGIN_RECOGNIZED_PATH, setup } from "./storage.js";
 export const trackReady = (app, intents, requestBackup, ready) => {
     const params = new URLSearchParams(location.hash.slice(1));
@@ -44,9 +44,6 @@ export const trackReady = (app, intents, requestBackup, ready) => {
         if ("createLoginRecognized" in provision) {
             storage[LOGIN_RECOGNIZED_PATH] = provision.createLoginRecognized;
         }
-        else if ("createVerification" in provision) {
-            storage[".core/verification.jwt"] = provision.createVerification;
-        }
     }
     ready();
 };

package/dist/utils-transport.d.ts

@@ -9,7 +9,7 @@ export type IntentEnvelope = {
 };
 export type StorageSetup = {
     method: "cloud";
-    jwt: string;
+    verification: string;
 } | {
     method: "localStorage";
 };
@@ -17,15 +17,13 @@ export type Provision = {
     setup: StorageSetup;
 } | {
     createLoginRecognized: string;
-} | {
-    createVerification: string;
 };
 /** @knipexternal */
 export type ProvisionEnvelope = {
     provisions: Provision[];
 };
-export type Login = {
-    email: string;
-    password: string;
-};
+export declare const login: import("valibot", { with: { "resolution-mode": "require" } }).ObjectSchema<{
+    readonly email: import("valibot", { with: { "resolution-mode": "require" } }).SchemaWithPipe<readonly [import("valibot", { with: { "resolution-mode": "require" } }).StringSchema<undefined>, import("valibot", { with: { "resolution-mode": "require" } }).EmailAction<string, undefined>]>;
+    readonly password: import("valibot", { with: { "resolution-mode": "require" } }).StringSchema<undefined>;
+}, undefined>;
 export declare const canBackup: boolean;

package/dist/utils-transport.js

@@ -1 +1,3 @@
+import { object, pipe, email, string } from "valibot";
+export const login = object({ email: pipe(string(), email()), password: string() });
 export const canBackup = navigator.userAgent.includes("CrOS") && Boolean(window.showDirectoryPicker);

package/dist/verification/attest-remote.d.ts

@@ -0,0 +1,2 @@
+export { attest_remote_default as default };
+declare function attest_remote_default(arg: any, init: any): Promise<any>;

package/dist/verification/attest-remote.js

@@ -0,0 +1,491 @@
+//#region node_modules/.pnpm/devalue@5.3.2/node_modules/devalue/src/utils.js
+var DevalueError = class extends Error {
+	/**
+	* @param {string} message
+	* @param {string[]} keys
+	*/
+	constructor(message, keys) {
+		super(message);
+		this.name = "DevalueError";
+		this.path = keys.join("");
+	}
+};
+/** @param {any} thing */
+function is_primitive(thing) {
+	return Object(thing) !== thing;
+}
+const object_proto_names = /* @__PURE__ */ Object.getOwnPropertyNames(Object.prototype).sort().join("\0");
+/** @param {any} thing */
+function is_plain_object(thing) {
+	const proto = Object.getPrototypeOf(thing);
+	return proto === Object.prototype || proto === null || Object.getPrototypeOf(proto) === null || Object.getOwnPropertyNames(proto).sort().join("\0") === object_proto_names;
+}
+/** @param {any} thing */
+function get_type(thing) {
+	return Object.prototype.toString.call(thing).slice(8, -1);
+}
+/** @param {string} char */
+function get_escaped_char(char) {
+	switch (char) {
+		case "\"": return "\\\"";
+		case "<": return "\\u003C";
+		case "\\": return "\\\\";
+		case "\n": return "\\n";
+		case "\r": return "\\r";
+		case "	": return "\\t";
+		case "\b": return "\\b";
+		case "\f": return "\\f";
+		case "\u2028": return "\\u2028";
+		case "\u2029": return "\\u2029";
+		default: return char < " " ? `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}` : "";
+	}
+}
+/** @param {string} str */
+function stringify_string(str) {
+	let result = "";
+	let last_pos = 0;
+	const len = str.length;
+	for (let i = 0; i < len; i += 1) {
+		const char = str[i];
+		const replacement = get_escaped_char(char);
+		if (replacement) {
+			result += str.slice(last_pos, i) + replacement;
+			last_pos = i + 1;
+		}
+	}
+	return `"${last_pos === 0 ? str : result + str.slice(last_pos)}"`;
+}
+/** @param {Record<string | symbol, any>} object */
+function enumerable_symbols(object) {
+	return Object.getOwnPropertySymbols(object).filter((symbol) => Object.getOwnPropertyDescriptor(object, symbol).enumerable);
+}
+const is_identifier = /^[a-zA-Z_$][a-zA-Z_$0-9]*$/;
+/** @param {string} key */
+function stringify_key(key) {
+	return is_identifier.test(key) ? "." + key : "[" + JSON.stringify(key) + "]";
+}
+
+//#endregion
+//#region node_modules/.pnpm/devalue@5.3.2/node_modules/devalue/src/base64.js
+/**
+* Base64 Encodes an arraybuffer
+* @param {ArrayBuffer} arraybuffer
+* @returns {string}
+*/
+function encode64(arraybuffer) {
+	const dv = new DataView(arraybuffer);
+	let binaryString = "";
+	for (let i = 0; i < arraybuffer.byteLength; i++) binaryString += String.fromCharCode(dv.getUint8(i));
+	return binaryToAscii(binaryString);
+}
+/**
+* Decodes a base64 string into an arraybuffer
+* @param {string} string
+* @returns {ArrayBuffer}
+*/
+function decode64(string) {
+	const binaryString = asciiToBinary(string);
+	const arraybuffer = new ArrayBuffer(binaryString.length);
+	const dv = new DataView(arraybuffer);
+	for (let i = 0; i < arraybuffer.byteLength; i++) dv.setUint8(i, binaryString.charCodeAt(i));
+	return arraybuffer;
+}
+const KEY_STRING = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+/**
+* Substitute for atob since it's deprecated in node.
+* Does not do any input validation.
+*
+* @see https://github.com/jsdom/abab/blob/master/lib/atob.js
+*
+* @param {string} data
+* @returns {string}
+*/
+function asciiToBinary(data) {
+	if (data.length % 4 === 0) data = data.replace(/==?$/, "");
+	let output = "";
+	let buffer = 0;
+	let accumulatedBits = 0;
+	for (let i = 0; i < data.length; i++) {
+		buffer <<= 6;
+		buffer |= KEY_STRING.indexOf(data[i]);
+		accumulatedBits += 6;
+		if (accumulatedBits === 24) {
+			output += String.fromCharCode((buffer & 16711680) >> 16);
+			output += String.fromCharCode((buffer & 65280) >> 8);
+			output += String.fromCharCode(buffer & 255);
+			buffer = accumulatedBits = 0;
+		}
+	}
+	if (accumulatedBits === 12) {
+		buffer >>= 4;
+		output += String.fromCharCode(buffer);
+	} else if (accumulatedBits === 18) {
+		buffer >>= 2;
+		output += String.fromCharCode((buffer & 65280) >> 8);
+		output += String.fromCharCode(buffer & 255);
+	}
+	return output;
+}
+/**
+* Substitute for btoa since it's deprecated in node.
+* Does not do any input validation.
+*
+* @see https://github.com/jsdom/abab/blob/master/lib/btoa.js
+*
+* @param {string} str
+* @returns {string}
+*/
+function binaryToAscii(str) {
+	let out = "";
+	for (let i = 0; i < str.length; i += 3) {
+		/** @type {[number, number, number, number]} */
+		const groupsOfSix = [
+			void 0,
+			void 0,
+			void 0,
+			void 0
+		];
+		groupsOfSix[0] = str.charCodeAt(i) >> 2;
+		groupsOfSix[1] = (str.charCodeAt(i) & 3) << 4;
+		if (str.length > i + 1) {
+			groupsOfSix[1] |= str.charCodeAt(i + 1) >> 4;
+			groupsOfSix[2] = (str.charCodeAt(i + 1) & 15) << 2;
+		}
+		if (str.length > i + 2) {
+			groupsOfSix[2] |= str.charCodeAt(i + 2) >> 6;
+			groupsOfSix[3] = str.charCodeAt(i + 2) & 63;
+		}
+		for (let j = 0; j < groupsOfSix.length; j++) if (typeof groupsOfSix[j] === "undefined") out += "=";
+		else out += KEY_STRING[groupsOfSix[j]];
+	}
+	return out;
+}
+
+//#endregion
+//#region node_modules/.pnpm/devalue@5.3.2/node_modules/devalue/src/constants.js
+const UNDEFINED = -1;
+const HOLE = -2;
+const NAN = -3;
+const POSITIVE_INFINITY = -4;
+const NEGATIVE_INFINITY = -5;
+const NEGATIVE_ZERO = -6;
+
+//#endregion
+//#region node_modules/.pnpm/devalue@5.3.2/node_modules/devalue/src/parse.js
+/**
+* Revive a value serialized with `devalue.stringify`
+* @param {string} serialized
+* @param {Record<string, (value: any) => any>} [revivers]
+*/
+function parse(serialized, revivers) {
+	return unflatten(JSON.parse(serialized), revivers);
+}
+/**
+* Revive a value flattened with `devalue.stringify`
+* @param {number | any[]} parsed
+* @param {Record<string, (value: any) => any>} [revivers]
+*/
+function unflatten(parsed, revivers) {
+	if (typeof parsed === "number") return hydrate(parsed, true);
+	if (!Array.isArray(parsed) || parsed.length === 0) throw new Error("Invalid input");
+	const values = parsed;
+	const hydrated = Array(values.length);
+	/**
+	* @param {number} index
+	* @returns {any}
+	*/
+	function hydrate(index, standalone = false) {
+		if (index === UNDEFINED) return void 0;
+		if (index === NAN) return NaN;
+		if (index === POSITIVE_INFINITY) return Infinity;
+		if (index === NEGATIVE_INFINITY) return -Infinity;
+		if (index === NEGATIVE_ZERO) return -0;
+		if (standalone || typeof index !== "number") throw new Error(`Invalid input`);
+		if (index in hydrated) return hydrated[index];
+		const value = values[index];
+		if (!value || typeof value !== "object") hydrated[index] = value;
+		else if (Array.isArray(value)) if (typeof value[0] === "string") {
+			const type = value[0];
+			const reviver = revivers?.[type];
+			if (reviver) return hydrated[index] = reviver(hydrate(value[1]));
+			switch (type) {
+				case "Date":
+					hydrated[index] = new Date(value[1]);
+					break;
+				case "Set":
+					const set = /* @__PURE__ */ new Set();
+					hydrated[index] = set;
+					for (let i = 1; i < value.length; i += 1) set.add(hydrate(value[i]));
+					break;
+				case "Map":
+					const map = /* @__PURE__ */ new Map();
+					hydrated[index] = map;
+					for (let i = 1; i < value.length; i += 2) map.set(hydrate(value[i]), hydrate(value[i + 1]));
+					break;
+				case "RegExp":
+					hydrated[index] = new RegExp(value[1], value[2]);
+					break;
+				case "Object":
+					hydrated[index] = Object(value[1]);
+					break;
+				case "BigInt":
+					hydrated[index] = BigInt(value[1]);
+					break;
+				case "null":
+					const obj = Object.create(null);
+					hydrated[index] = obj;
+					for (let i = 1; i < value.length; i += 2) obj[value[i]] = hydrate(value[i + 1]);
+					break;
+				case "Int8Array":
+				case "Uint8Array":
+				case "Uint8ClampedArray":
+				case "Int16Array":
+				case "Uint16Array":
+				case "Int32Array":
+				case "Uint32Array":
+				case "Float32Array":
+				case "Float64Array":
+				case "BigInt64Array":
+				case "BigUint64Array": {
+					const TypedArrayConstructor = globalThis[type];
+					const typedArray = new TypedArrayConstructor(hydrate(value[1]));
+					hydrated[index] = value[2] !== void 0 ? typedArray.subarray(value[2], value[3]) : typedArray;
+					break;
+				}
+				case "ArrayBuffer": {
+					const base64 = value[1];
+					hydrated[index] = decode64(base64);
+					break;
+				}
+				case "Temporal.Duration":
+				case "Temporal.Instant":
+				case "Temporal.PlainDate":
+				case "Temporal.PlainTime":
+				case "Temporal.PlainDateTime":
+				case "Temporal.PlainMonthDay":
+				case "Temporal.PlainYearMonth":
+				case "Temporal.ZonedDateTime": {
+					const temporalName = type.slice(9);
+					hydrated[index] = Temporal[temporalName].from(value[1]);
+					break;
+				}
+				case "URL":
+					hydrated[index] = new URL(value[1]);
+					break;
+				case "URLSearchParams":
+					hydrated[index] = new URLSearchParams(value[1]);
+					break;
+				default: throw new Error(`Unknown type ${type}`);
+			}
+		} else {
+			const array = new Array(value.length);
+			hydrated[index] = array;
+			for (let i = 0; i < value.length; i += 1) {
+				const n = value[i];
+				if (n === HOLE) continue;
+				array[i] = hydrate(n);
+			}
+		}
+		else {
+			/** @type {Record<string, any>} */
+			const object = {};
+			hydrated[index] = object;
+			for (const key in value) {
+				if (key === "__proto__") throw new Error("Cannot parse an object with a `__proto__` property");
+				const n = value[key];
+				object[key] = hydrate(n);
+			}
+		}
+		return hydrated[index];
+	}
+	return hydrate(0);
+}
+
+//#endregion
+//#region node_modules/.pnpm/devalue@5.3.2/node_modules/devalue/src/stringify.js
+/**
+* Turn a value into a JSON string that can be parsed with `devalue.parse`
+* @param {any} value
+* @param {Record<string, (value: any) => any>} [reducers]
+*/
+function stringify(value, reducers) {
+	/** @type {any[]} */
+	const stringified = [];
+	/** @type {Map<any, number>} */
+	const indexes = /* @__PURE__ */ new Map();
+	/** @type {Array<{ key: string, fn: (value: any) => any }>} */
+	const custom = [];
+	if (reducers) for (const key of Object.getOwnPropertyNames(reducers)) custom.push({
+		key,
+		fn: reducers[key]
+	});
+	/** @type {string[]} */
+	const keys = [];
+	let p = 0;
+	/** @param {any} thing */
+	function flatten(thing) {
+		if (typeof thing === "function") throw new DevalueError(`Cannot stringify a function`, keys);
+		if (thing === void 0) return UNDEFINED;
+		if (Number.isNaN(thing)) return NAN;
+		if (thing === Infinity) return POSITIVE_INFINITY;
+		if (thing === -Infinity) return NEGATIVE_INFINITY;
+		if (thing === 0 && 1 / thing < 0) return NEGATIVE_ZERO;
+		if (indexes.has(thing)) return indexes.get(thing);
+		const index$1 = p++;
+		indexes.set(thing, index$1);
+		for (const { key, fn } of custom) {
+			const value$1 = fn(thing);
+			if (value$1) {
+				stringified[index$1] = `["${key}",${flatten(value$1)}]`;
+				return index$1;
+			}
+		}
+		let str = "";
+		if (is_primitive(thing)) str = stringify_primitive(thing);
+		else {
+			const type = get_type(thing);
+			switch (type) {
+				case "Number":
+				case "String":
+				case "Boolean":
+					str = `["Object",${stringify_primitive(thing)}]`;
+					break;
+				case "BigInt":
+					str = `["BigInt",${thing}]`;
+					break;
+				case "Date":
+					str = `["Date","${!isNaN(thing.getDate()) ? thing.toISOString() : ""}"]`;
+					break;
+				case "URL":
+					str = `["URL",${stringify_string(thing.toString())}]`;
+					break;
+				case "URLSearchParams":
+					str = `["URLSearchParams",${stringify_string(thing.toString())}]`;
+					break;
+				case "RegExp":
+					const { source, flags } = thing;
+					str = flags ? `["RegExp",${stringify_string(source)},"${flags}"]` : `["RegExp",${stringify_string(source)}]`;
+					break;
+				case "Array":
+					str = "[";
+					for (let i = 0; i < thing.length; i += 1) {
+						if (i > 0) str += ",";
+						if (i in thing) {
+							keys.push(`[${i}]`);
+							str += flatten(thing[i]);
+							keys.pop();
+						} else str += HOLE;
+					}
+					str += "]";
+					break;
+				case "Set":
+					str = "[\"Set\"";
+					for (const value$1 of thing) str += `,${flatten(value$1)}`;
+					str += "]";
+					break;
+				case "Map":
+					str = "[\"Map\"";
+					for (const [key, value$1] of thing) {
+						keys.push(`.get(${is_primitive(key) ? stringify_primitive(key) : "..."})`);
+						str += `,${flatten(key)},${flatten(value$1)}`;
+						keys.pop();
+					}
+					str += "]";
+					break;
+				case "Int8Array":
+				case "Uint8Array":
+				case "Uint8ClampedArray":
+				case "Int16Array":
+				case "Uint16Array":
+				case "Int32Array":
+				case "Uint32Array":
+				case "Float32Array":
+				case "Float64Array":
+				case "BigInt64Array":
+				case "BigUint64Array": {
+					/** @type {import("./types.js").TypedArray} */
+					const typedArray = thing;
+					str = "[\"" + type + "\"," + flatten(typedArray.buffer);
+					const a = thing.byteOffset;
+					const b = a + thing.byteLength;
+					if (a > 0 || b !== typedArray.buffer.byteLength) {
+						const m = +/(\d+)/.exec(type)[1] / 8;
+						str += `,${a / m},${b / m}`;
+					}
+					str += "]";
+					break;
+				}
+				case "ArrayBuffer":
+					str = `["ArrayBuffer","${encode64(thing)}"]`;
+					break;
+				case "Temporal.Duration":
+				case "Temporal.Instant":
+				case "Temporal.PlainDate":
+				case "Temporal.PlainTime":
+				case "Temporal.PlainDateTime":
+				case "Temporal.PlainMonthDay":
+				case "Temporal.PlainYearMonth":
+				case "Temporal.ZonedDateTime":
+					str = `["${type}",${stringify_string(thing.toString())}]`;
+					break;
+				default:
+					if (!is_plain_object(thing)) throw new DevalueError(`Cannot stringify arbitrary non-POJOs`, keys);
+					if (enumerable_symbols(thing).length > 0) throw new DevalueError(`Cannot stringify POJOs with symbolic keys`, keys);
+					if (Object.getPrototypeOf(thing) === null) {
+						str = "[\"null\"";
+						for (const key in thing) {
+							keys.push(stringify_key(key));
+							str += `,${stringify_string(key)},${flatten(thing[key])}`;
+							keys.pop();
+						}
+						str += "]";
+					} else {
+						str = "{";
+						let started = false;
+						for (const key in thing) {
+							if (started) str += ",";
+							started = true;
+							keys.push(stringify_key(key));
+							str += `${stringify_string(key)}:${flatten(thing[key])}`;
+							keys.pop();
+						}
+						str += "}";
+					}
+			}
+		}
+		stringified[index$1] = str;
+		return index$1;
+	}
+	const index = flatten(value);
+	if (index < 0) return `${index}`;
+	return `[${stringified.join(",")}]`;
+}
+/**
+* @param {any} thing
+* @returns {string}
+*/
+function stringify_primitive(thing) {
+	const type = typeof thing;
+	if (type === "string") return stringify_string(thing);
+	if (thing instanceof String) return stringify_string(thing.toString());
+	if (thing === void 0) return UNDEFINED.toString();
+	if (thing === 0 && 1 / thing < 0) return NEGATIVE_ZERO.toString();
+	if (type === "bigint") return `["BigInt","${thing}"]`;
+	return String(thing);
+}
+
+//#endregion
+//#region src/lib/verification/attest.remote.ts
+async function attest_remote_default(arg, init) {
+	const res = await fetch("https://benignmonoserver.fly.dev/b1c8ae45b4", {
+		method: "POST",
+		body: stringify(arg),
+		...init
+	});
+	if (!res.ok) throw new Error(await res.text());
+	if (!res.headers.get("content-type")?.includes("application/json")) return res;
+	return parse(await res.text());
+}
+
+//#endregion
+export { attest_remote_default as default };

package/dist/verification/gen.sh

@@ -0,0 +1,2 @@
+openssl ecparam -genkey -name prime256v1 -noout | openssl pkcs8 -topk8 -nocrypt -out private.pem
+openssl ec -in private.pem -pubout -out public.pem

package/dist/verification/public-key.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "-----BEGIN PUBLIC KEY-----\nMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERXBMZBkx95Iua82tR9gsmdegOwuB\nOGgbkB6h9s4DROhBRkpubcAiu5Qa9GizbWk1g0RwrnrdVo7yxENcEs2+zw==\n-----END PUBLIC KEY-----\n";
+export default _default;

package/dist/verification/public-key.js

@@ -0,0 +1,5 @@
+export default `-----BEGIN PUBLIC KEY-----
+MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAERXBMZBkx95Iua82tR9gsmdegOwuB
+OGgbkB6h9s4DROhBRkpubcAiu5Qa9GizbWk1g0RwrnrdVo7yxENcEs2+zw==
+-----END PUBLIC KEY-----
+`;

package/dist/verification/studentvue.d.ts

@@ -0,0 +1,6 @@
+declare const _default: ({ base, userID, password }: {
+    base: string;
+    userID: string;
+    password: string;
+}, name: string, params?: Record<string, string>) => Promise<any>;
+export default _default;

package/dist/verification/studentvue.js

@@ -0,0 +1,45 @@
+import { XMLParser } from "fast-xml-parser";
+const build = (object) => {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(object)) {
+        params.set(key, value);
+    }
+    return params;
+};
+const parser = new XMLParser({ ignoreAttributes: false });
+export default async ({ base, userID, password }, name, params = {}) => {
+    const request = build({
+        userID,
+        password,
+        skipLoginLog: "true",
+        parent: "false",
+        webServiceHandleName: "PXPWebServices",
+        methodName: name,
+        paramStr: `<Parms>${Object.keys(params)
+            .map((key) => `<${key}>${params[key]}</${key}>`)
+            .join("")}</Parms>`,
+    });
+    const response = await fetch(`${base}/Service/PXPCommunication.asmx/ProcessWebServiceRequest`, {
+        method: "POST",
+        body: request,
+        headers: {
+            "content-type": "application/x-www-form-urlencoded",
+        },
+    });
+    const dataWrap = await response.text();
+    const data = dataWrap
+        .split(`<string xmlns="http://edupoint.com/webservices/">`)[1]
+        .split("</string>")[0]
+        .replace(/&amp;/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">");
+    const xml = parser.parse(data);
+    const err = xml.RT_ERROR;
+    if (err) {
+        if (err["@_ERROR_MESSAGE"].startsWith("Invalid user id or password")) {
+            throw new Error("Invalid auth");
+        }
+        throw new Error("StudentVue error");
+    }
+    return xml;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monoidentity",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "repository": "KTibow/monoidentity",
   "author": {
     "name": "KTibow"
@@ -31,21 +31,28 @@
     "svelte": "^5.0.0"
   },
   "dependencies": {
+    "@tsndr/cloudflare-worker-jwt": "^3.2.0",
     "devalue": "^5.3.2",
-    "idb": "^8.0.3"
+    "idb": "^8.0.3",
+    "valibot": "^1.1.0"
   },
   "devDependencies": {
     "@sveltejs/adapter-static": "^3.0.9",
-    "@sveltejs/kit": "^2.22.0",
-    "@sveltejs/package": "^2.0.0",
-    "@sveltejs/vite-plugin-svelte": "^6.0.0",
+    "@sveltejs/kit": "^2.43.5",
+    "@sveltejs/package": "^2.5.4",
+    "@sveltejs/vite-plugin-svelte": "^6.2.1",
     "@types/wicg-file-system-access": "^2023.10.6",
-    "knip": "^5.64.0",
-    "publint": "^0.3.2",
-    "svelte": "^5.0.0",
-    "svelte-check": "^4.0.0",
-    "typescript": "^5.0.0",
-    "vite": "^7.0.4"
+    "fast-xml-parser": "^5.2.5",
+    "knip": "^5.64.1",
+    "monoserve": "^2.2.0",
+    "publint": "^0.3.13",
+    "rolldown": "1.0.0-beta.40",
+    "school-districts": "^2.0.0",
+    "svelte": "^5.39.6",
+    "svelte-check": "^4.3.2",
+    "tinyglobby": "^0.2.15",
+    "typescript": "^5.9.2",
+    "vite": "^7.1.7"
   },
   "keywords": [
     "svelte"