@openpalm/ui 0.13.0-beta.3 → 0.13.0-beta.5

package/build/server/chunks/_server.ts-B6IuU4lX.js

@@ -0,0 +1,964 @@
+import { aE as readStackRuntimeEnv, aq as mintDirectPrincipalPairingCode } from './src-AHSKeKr0.js';
+import { i as isLoopback } from './network-preset-CJ1RRnki.js';
+import { g as getState } from './state-CzXOEt0t.js';
+import { v as validateEndpointUrl } from './endpoints-CnnGlw2U.js';
+import { l as requireCapability, d as getRequestId, w as withAdminBody, e as errorResponse, k as jsonResponse } from './helpers-9U7R7yqL.js';
+import './chunk-DOvWTNp_.js';
+import 'node:module';
+import 'node:fs';
+import 'node:child_process';
+import 'node:path';
+import 'buffer';
+import 'node:url';
+import 'node:os';
+import 'node:crypto';
+import 'events';
+import 'fs';
+import 'node:events';
+import 'node:stream';
+import 'node:string_decoder';
+import 'path';
+import 'assert';
+import 'zlib';
+import 'node:assert';
+import 'node:fs/promises';
+import './features-BUWlozR5.js';
+
+//#region ../../node_modules/.bun/uqr@0.1.3/node_modules/uqr/dist/index.mjs
+var QrCodeDataType = /* @__PURE__ */ ((QrCodeDataType2) => {
+	QrCodeDataType2[QrCodeDataType2["Border"] = -1] = "Border";
+	QrCodeDataType2[QrCodeDataType2["Data"] = 0] = "Data";
+	QrCodeDataType2[QrCodeDataType2["Function"] = 1] = "Function";
+	QrCodeDataType2[QrCodeDataType2["Position"] = 2] = "Position";
+	QrCodeDataType2[QrCodeDataType2["Timing"] = 3] = "Timing";
+	QrCodeDataType2[QrCodeDataType2["Alignment"] = 4] = "Alignment";
+	return QrCodeDataType2;
+})(QrCodeDataType || {});
+var LOW = [0, 1];
+var MEDIUM = [1, 0];
+var QUARTILE = [2, 3];
+var HIGH = [3, 2];
+var EccMap = {
+	L: LOW,
+	M: MEDIUM,
+	Q: QUARTILE,
+	H: HIGH
+};
+var NUMERIC_REGEX = /^\d*$/;
+var ALPHANUMERIC_REGEX = /^[A-Z0-9 $%*+./:-]*$/;
+var ALPHANUMERIC_CHARSET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:";
+var MIN_VERSION = 1;
+var MAX_VERSION = 40;
+var PENALTY_N1 = 3;
+var PENALTY_N2 = 3;
+var PENALTY_N3 = 40;
+var PENALTY_N4 = 10;
+var ECC_CODEWORDS_PER_BLOCK = [
+	[
+		-1,
+		7,
+		10,
+		15,
+		20,
+		26,
+		18,
+		20,
+		24,
+		30,
+		18,
+		20,
+		24,
+		26,
+		30,
+		22,
+		24,
+		28,
+		30,
+		28,
+		28,
+		28,
+		28,
+		30,
+		30,
+		26,
+		28,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30
+	],
+	[
+		-1,
+		10,
+		16,
+		26,
+		18,
+		24,
+		16,
+		18,
+		22,
+		22,
+		26,
+		30,
+		22,
+		22,
+		24,
+		24,
+		28,
+		28,
+		26,
+		26,
+		26,
+		26,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28,
+		28
+	],
+	[
+		-1,
+		13,
+		22,
+		18,
+		26,
+		18,
+		24,
+		18,
+		22,
+		20,
+		24,
+		28,
+		26,
+		24,
+		20,
+		30,
+		24,
+		28,
+		28,
+		26,
+		30,
+		28,
+		30,
+		30,
+		30,
+		30,
+		28,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30
+	],
+	[
+		-1,
+		17,
+		28,
+		22,
+		16,
+		22,
+		28,
+		26,
+		26,
+		24,
+		28,
+		24,
+		28,
+		22,
+		24,
+		24,
+		30,
+		28,
+		28,
+		26,
+		28,
+		30,
+		24,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30,
+		30
+	]
+];
+var NUM_ERROR_CORRECTION_BLOCKS = [
+	[
+		-1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		2,
+		2,
+		2,
+		2,
+		4,
+		4,
+		4,
+		4,
+		4,
+		6,
+		6,
+		6,
+		6,
+		7,
+		8,
+		8,
+		9,
+		9,
+		10,
+		12,
+		12,
+		12,
+		13,
+		14,
+		15,
+		16,
+		17,
+		18,
+		19,
+		19,
+		20,
+		21,
+		22,
+		24,
+		25
+	],
+	[
+		-1,
+		1,
+		1,
+		1,
+		2,
+		2,
+		4,
+		4,
+		4,
+		5,
+		5,
+		5,
+		8,
+		9,
+		9,
+		10,
+		10,
+		11,
+		13,
+		14,
+		16,
+		17,
+		17,
+		18,
+		20,
+		21,
+		23,
+		25,
+		26,
+		28,
+		29,
+		31,
+		33,
+		35,
+		37,
+		38,
+		40,
+		43,
+		45,
+		47,
+		49
+	],
+	[
+		-1,
+		1,
+		1,
+		2,
+		2,
+		4,
+		4,
+		6,
+		6,
+		8,
+		8,
+		8,
+		10,
+		12,
+		16,
+		12,
+		17,
+		16,
+		18,
+		21,
+		20,
+		23,
+		23,
+		25,
+		27,
+		29,
+		34,
+		34,
+		35,
+		38,
+		40,
+		43,
+		45,
+		48,
+		51,
+		53,
+		56,
+		59,
+		62,
+		65,
+		68
+	],
+	[
+		-1,
+		1,
+		1,
+		2,
+		4,
+		4,
+		4,
+		5,
+		6,
+		8,
+		8,
+		11,
+		11,
+		16,
+		16,
+		18,
+		16,
+		19,
+		21,
+		25,
+		25,
+		25,
+		34,
+		30,
+		32,
+		35,
+		37,
+		40,
+		42,
+		45,
+		48,
+		51,
+		54,
+		57,
+		60,
+		63,
+		66,
+		70,
+		74,
+		77,
+		81
+	]
+];
+var QrCode = class {
+	constructor(version, ecc, dataCodewords, msk) {
+		this.version = version;
+		this.ecc = ecc;
+		if (version < MIN_VERSION || version > MAX_VERSION) throw new RangeError("Version value out of range");
+		if (msk < -1 || msk > 7) throw new RangeError("Mask value out of range");
+		this.size = version * 4 + 17;
+		const row = Array.from({ length: this.size }).fill(false);
+		for (let i = 0; i < this.size; i++) {
+			this.modules.push(row.slice());
+			this.types.push(row.map(() => 0));
+		}
+		this.drawFunctionPatterns();
+		const allCodewords = this.addEccAndInterleave(dataCodewords);
+		this.drawCodewords(allCodewords);
+		if (msk === -1) {
+			let minPenalty = 1e9;
+			for (let i = 0; i < 8; i++) {
+				this.applyMask(i);
+				this.drawFormatBits(i);
+				const penalty = this.getPenaltyScore();
+				if (penalty < minPenalty) {
+					msk = i;
+					minPenalty = penalty;
+				}
+				this.applyMask(i);
+			}
+		}
+		this.mask = msk;
+		this.applyMask(msk);
+		this.drawFormatBits(msk);
+	}
+	size;
+	mask;
+	modules = [];
+	types = [];
+	getModule(x, y) {
+		return x >= 0 && x < this.size && y >= 0 && y < this.size && this.modules[y][x];
+	}
+	drawFunctionPatterns() {
+		for (let i = 0; i < this.size; i++) {
+			this.setFunctionModule(6, i, i % 2 === 0, QrCodeDataType.Timing);
+			this.setFunctionModule(i, 6, i % 2 === 0, QrCodeDataType.Timing);
+		}
+		this.drawFinderPattern(3, 3);
+		this.drawFinderPattern(this.size - 4, 3);
+		this.drawFinderPattern(3, this.size - 4);
+		const alignPatPos = this.getAlignmentPatternPositions();
+		const numAlign = alignPatPos.length;
+		for (let i = 0; i < numAlign; i++) for (let j = 0; j < numAlign; j++) if (!(i === 0 && j === 0 || i === 0 && j === numAlign - 1 || i === numAlign - 1 && j === 0)) this.drawAlignmentPattern(alignPatPos[i], alignPatPos[j]);
+		this.drawFormatBits(0);
+		this.drawVersion();
+	}
+	drawFormatBits(mask) {
+		const data = this.ecc[1] << 3 | mask;
+		let rem = data;
+		for (let i = 0; i < 10; i++) rem = rem << 1 ^ (rem >>> 9) * 1335;
+		const bits = (data << 10 | rem) ^ 21522;
+		for (let i = 0; i <= 5; i++) this.setFunctionModule(8, i, getBit(bits, i));
+		this.setFunctionModule(8, 7, getBit(bits, 6));
+		this.setFunctionModule(8, 8, getBit(bits, 7));
+		this.setFunctionModule(7, 8, getBit(bits, 8));
+		for (let i = 9; i < 15; i++) this.setFunctionModule(14 - i, 8, getBit(bits, i));
+		for (let i = 0; i < 8; i++) this.setFunctionModule(this.size - 1 - i, 8, getBit(bits, i));
+		for (let i = 8; i < 15; i++) this.setFunctionModule(8, this.size - 15 + i, getBit(bits, i));
+		this.setFunctionModule(8, this.size - 8, true);
+	}
+	drawVersion() {
+		if (this.version < 7) return;
+		let rem = this.version;
+		for (let i = 0; i < 12; i++) rem = rem << 1 ^ (rem >>> 11) * 7973;
+		const bits = this.version << 12 | rem;
+		for (let i = 0; i < 18; i++) {
+			const color = getBit(bits, i);
+			const a = this.size - 11 + i % 3;
+			const b = Math.floor(i / 3);
+			this.setFunctionModule(a, b, color);
+			this.setFunctionModule(b, a, color);
+		}
+	}
+	drawFinderPattern(x, y) {
+		for (let dy = -4; dy <= 4; dy++) for (let dx = -4; dx <= 4; dx++) {
+			const dist = Math.max(Math.abs(dx), Math.abs(dy));
+			const xx = x + dx;
+			const yy = y + dy;
+			if (xx >= 0 && xx < this.size && yy >= 0 && yy < this.size) this.setFunctionModule(xx, yy, dist !== 2 && dist !== 4, QrCodeDataType.Position);
+		}
+	}
+	drawAlignmentPattern(x, y) {
+		for (let dy = -2; dy <= 2; dy++) for (let dx = -2; dx <= 2; dx++) this.setFunctionModule(x + dx, y + dy, Math.max(Math.abs(dx), Math.abs(dy)) !== 1, QrCodeDataType.Alignment);
+	}
+	setFunctionModule(x, y, isDark, type = QrCodeDataType.Function) {
+		this.modules[y][x] = isDark;
+		this.types[y][x] = type;
+	}
+	addEccAndInterleave(data) {
+		const ver = this.version;
+		const ecl = this.ecc;
+		if (data.length !== getNumDataCodewords(ver, ecl)) throw new RangeError("Invalid argument");
+		const numBlocks = NUM_ERROR_CORRECTION_BLOCKS[ecl[0]][ver];
+		const blockEccLen = ECC_CODEWORDS_PER_BLOCK[ecl[0]][ver];
+		const rawCodewords = Math.floor(getNumRawDataModules(ver) / 8);
+		const numShortBlocks = numBlocks - rawCodewords % numBlocks;
+		const shortBlockLen = Math.floor(rawCodewords / numBlocks);
+		const blocks = [];
+		const rsDiv = reedSolomonComputeDivisor(blockEccLen);
+		for (let i = 0, k = 0; i < numBlocks; i++) {
+			const dat = data.slice(k, k + shortBlockLen - blockEccLen + (i < numShortBlocks ? 0 : 1));
+			k += dat.length;
+			const ecc = reedSolomonComputeRemainder(dat, rsDiv);
+			if (i < numShortBlocks) dat.push(0);
+			blocks.push(dat.concat(ecc));
+		}
+		const result = [];
+		for (let i = 0; i < blocks[0].length; i++) blocks.forEach((block, j) => {
+			if (i !== shortBlockLen - blockEccLen || j >= numShortBlocks) result.push(block[i]);
+		});
+		return result;
+	}
+	drawCodewords(data) {
+		if (data.length !== Math.floor(getNumRawDataModules(this.version) / 8)) throw new RangeError("Invalid argument");
+		let i = 0;
+		for (let right = this.size - 1; right >= 1; right -= 2) {
+			if (right === 6) right = 5;
+			for (let vert = 0; vert < this.size; vert++) for (let j = 0; j < 2; j++) {
+				const x = right - j;
+				const y = (right + 1 & 2) === 0 ? this.size - 1 - vert : vert;
+				if (!this.types[y][x] && i < data.length * 8) {
+					this.modules[y][x] = getBit(data[i >>> 3], 7 - (i & 7));
+					i++;
+				}
+			}
+		}
+	}
+	applyMask(mask) {
+		if (mask < 0 || mask > 7) throw new RangeError("Mask value out of range");
+		for (let y = 0; y < this.size; y++) for (let x = 0; x < this.size; x++) {
+			let invert;
+			switch (mask) {
+				case 0:
+					invert = (x + y) % 2 === 0;
+					break;
+				case 1:
+					invert = y % 2 === 0;
+					break;
+				case 2:
+					invert = x % 3 === 0;
+					break;
+				case 3:
+					invert = (x + y) % 3 === 0;
+					break;
+				case 4:
+					invert = (Math.floor(x / 3) + Math.floor(y / 2)) % 2 === 0;
+					break;
+				case 5:
+					invert = x * y % 2 + x * y % 3 === 0;
+					break;
+				case 6:
+					invert = (x * y % 2 + x * y % 3) % 2 === 0;
+					break;
+				case 7:
+					invert = ((x + y) % 2 + x * y % 3) % 2 === 0;
+					break;
+				default: throw new Error("Unreachable");
+			}
+			if (!this.types[y][x] && invert) this.modules[y][x] = !this.modules[y][x];
+		}
+	}
+	getPenaltyScore() {
+		let result = 0;
+		for (let y = 0; y < this.size; y++) {
+			let runColor = false;
+			let runX = 0;
+			const runHistory = [
+				0,
+				0,
+				0,
+				0,
+				0,
+				0,
+				0
+			];
+			for (let x = 0; x < this.size; x++) if (this.modules[y][x] === runColor) {
+				runX++;
+				if (runX === 5) result += PENALTY_N1;
+				else if (runX > 5) result++;
+			} else {
+				this.finderPenaltyAddHistory(runX, runHistory);
+				if (!runColor) result += this.finderPenaltyCountPatterns(runHistory) * PENALTY_N3;
+				runColor = this.modules[y][x];
+				runX = 1;
+			}
+			result += this.finderPenaltyTerminateAndCount(runColor, runX, runHistory) * PENALTY_N3;
+		}
+		for (let x = 0; x < this.size; x++) {
+			let runColor = false;
+			let runY = 0;
+			const runHistory = [
+				0,
+				0,
+				0,
+				0,
+				0,
+				0,
+				0
+			];
+			for (let y = 0; y < this.size; y++) if (this.modules[y][x] === runColor) {
+				runY++;
+				if (runY === 5) result += PENALTY_N1;
+				else if (runY > 5) result++;
+			} else {
+				this.finderPenaltyAddHistory(runY, runHistory);
+				if (!runColor) result += this.finderPenaltyCountPatterns(runHistory) * PENALTY_N3;
+				runColor = this.modules[y][x];
+				runY = 1;
+			}
+			result += this.finderPenaltyTerminateAndCount(runColor, runY, runHistory) * PENALTY_N3;
+		}
+		for (let y = 0; y < this.size - 1; y++) for (let x = 0; x < this.size - 1; x++) {
+			const color = this.modules[y][x];
+			if (color === this.modules[y][x + 1] && color === this.modules[y + 1][x] && color === this.modules[y + 1][x + 1]) result += PENALTY_N2;
+		}
+		let dark = 0;
+		for (const row of this.modules) dark = row.reduce((sum, color) => sum + (color ? 1 : 0), dark);
+		const total = this.size * this.size;
+		const k = Math.ceil(Math.abs(dark * 20 - total * 10) / total) - 1;
+		result += k * PENALTY_N4;
+		return result;
+	}
+	getAlignmentPatternPositions() {
+		if (this.version === 1) return [];
+		else {
+			const numAlign = Math.floor(this.version / 7) + 2;
+			const step = this.version === 32 ? 26 : Math.ceil((this.version * 4 + 4) / (numAlign * 2 - 2)) * 2;
+			const result = [6];
+			for (let pos = this.size - 7; result.length < numAlign; pos -= step) result.splice(1, 0, pos);
+			return result;
+		}
+	}
+	finderPenaltyCountPatterns(runHistory) {
+		const n = runHistory[1];
+		const core = n > 0 && runHistory[2] === n && runHistory[3] === n * 3 && runHistory[4] === n && runHistory[5] === n;
+		return (core && runHistory[0] >= n * 4 && runHistory[6] >= n ? 1 : 0) + (core && runHistory[6] >= n * 4 && runHistory[0] >= n ? 1 : 0);
+	}
+	finderPenaltyTerminateAndCount(currentRunColor, currentRunLength, runHistory) {
+		if (currentRunColor) {
+			this.finderPenaltyAddHistory(currentRunLength, runHistory);
+			currentRunLength = 0;
+		}
+		currentRunLength += this.size;
+		this.finderPenaltyAddHistory(currentRunLength, runHistory);
+		return this.finderPenaltyCountPatterns(runHistory);
+	}
+	finderPenaltyAddHistory(currentRunLength, runHistory) {
+		if (runHistory[0] === 0) currentRunLength += this.size;
+		runHistory.pop();
+		runHistory.unshift(currentRunLength);
+	}
+};
+function appendBits(val, len, bb) {
+	if (len < 0 || len > 31 || val >>> len !== 0) throw new RangeError("Value out of range");
+	for (let i = len - 1; i >= 0; i--) bb.push(val >>> i & 1);
+}
+function getBit(x, i) {
+	return (x >>> i & 1) !== 0;
+}
+var QrSegment = class {
+	constructor(mode, numChars, bitData) {
+		this.mode = mode;
+		this.numChars = numChars;
+		this.bitData = bitData;
+		if (numChars < 0) throw new RangeError("Invalid argument");
+		this.bitData = bitData.slice();
+	}
+	getData() {
+		return this.bitData.slice();
+	}
+};
+var MODE_NUMERIC = [
+	1,
+	10,
+	12,
+	14
+];
+var MODE_ALPHANUMERIC = [
+	2,
+	9,
+	11,
+	13
+];
+var MODE_BYTE = [
+	4,
+	8,
+	16,
+	16
+];
+function numCharCountBits(mode, ver) {
+	return mode[Math.floor((ver + 7) / 17) + 1];
+}
+function makeBytes(data) {
+	const bb = [];
+	for (const b of data) appendBits(b, 8, bb);
+	return new QrSegment(MODE_BYTE, data.length, bb);
+}
+function makeNumeric(digits) {
+	if (!isNumeric(digits)) throw new RangeError("String contains non-numeric characters");
+	const bb = [];
+	for (let i = 0; i < digits.length;) {
+		const n = Math.min(digits.length - i, 3);
+		appendBits(Number.parseInt(digits.substring(i, i + n), 10), n * 3 + 1, bb);
+		i += n;
+	}
+	return new QrSegment(MODE_NUMERIC, digits.length, bb);
+}
+function makeAlphanumeric(text) {
+	if (!isAlphanumeric(text)) throw new RangeError("String contains unencodable characters in alphanumeric mode");
+	const bb = [];
+	let i;
+	for (i = 0; i + 2 <= text.length; i += 2) {
+		let temp = ALPHANUMERIC_CHARSET.indexOf(text.charAt(i)) * 45;
+		temp += ALPHANUMERIC_CHARSET.indexOf(text.charAt(i + 1));
+		appendBits(temp, 11, bb);
+	}
+	if (i < text.length) appendBits(ALPHANUMERIC_CHARSET.indexOf(text.charAt(i)), 6, bb);
+	return new QrSegment(MODE_ALPHANUMERIC, text.length, bb);
+}
+function makeSegments(text) {
+	if (text === "") return [];
+	else if (isNumeric(text)) return [makeNumeric(text)];
+	else if (isAlphanumeric(text)) return [makeAlphanumeric(text)];
+	else return [makeBytes(toUtf8ByteArray(text))];
+}
+function isNumeric(text) {
+	return NUMERIC_REGEX.test(text);
+}
+function isAlphanumeric(text) {
+	return ALPHANUMERIC_REGEX.test(text);
+}
+function getTotalBits(segs, version) {
+	let result = 0;
+	for (const seg of segs) {
+		const ccbits = numCharCountBits(seg.mode, version);
+		if (seg.numChars >= 1 << ccbits) return Number.POSITIVE_INFINITY;
+		result += 4 + ccbits + seg.bitData.length;
+	}
+	return result;
+}
+function toUtf8ByteArray(str) {
+	str = encodeURI(str);
+	const result = [];
+	for (let i = 0; i < str.length; i++) if (str.charAt(i) !== "%") result.push(str.charCodeAt(i));
+	else {
+		result.push(Number.parseInt(str.substring(i + 1, i + 3), 16));
+		i += 2;
+	}
+	return result;
+}
+function getNumRawDataModules(ver) {
+	if (ver < MIN_VERSION || ver > MAX_VERSION) throw new RangeError("Version number out of range");
+	let result = (16 * ver + 128) * ver + 64;
+	if (ver >= 2) {
+		const numAlign = Math.floor(ver / 7) + 2;
+		result -= (25 * numAlign - 10) * numAlign - 55;
+		if (ver >= 7) result -= 36;
+	}
+	return result;
+}
+function getNumDataCodewords(ver, ecl) {
+	return Math.floor(getNumRawDataModules(ver) / 8) - ECC_CODEWORDS_PER_BLOCK[ecl[0]][ver] * NUM_ERROR_CORRECTION_BLOCKS[ecl[0]][ver];
+}
+function reedSolomonComputeDivisor(degree) {
+	if (degree < 1 || degree > 255) throw new RangeError("Degree out of range");
+	const result = [];
+	for (let i = 0; i < degree - 1; i++) result.push(0);
+	result.push(1);
+	let root = 1;
+	for (let i = 0; i < degree; i++) {
+		for (let j = 0; j < result.length; j++) {
+			result[j] = reedSolomonMultiply(result[j], root);
+			if (j + 1 < result.length) result[j] ^= result[j + 1];
+		}
+		root = reedSolomonMultiply(root, 2);
+	}
+	return result;
+}
+function reedSolomonComputeRemainder(data, divisor) {
+	const result = divisor.map((_) => 0);
+	for (const b of data) {
+		const factor = b ^ result.shift();
+		result.push(0);
+		divisor.forEach((coef, i) => result[i] ^= reedSolomonMultiply(coef, factor));
+	}
+	return result;
+}
+function reedSolomonMultiply(x, y) {
+	if (x >>> 8 !== 0 || y >>> 8 !== 0) throw new RangeError("Byte out of range");
+	let z = 0;
+	for (let i = 7; i >= 0; i--) {
+		z = z << 1 ^ (z >>> 7) * 285;
+		z ^= (y >>> i & 1) * x;
+	}
+	return z;
+}
+function encodeSegments(segs, ecl, minVersion = 1, maxVersion = 40, mask = -1, boostEcl = true) {
+	if (!(MIN_VERSION <= minVersion && minVersion <= maxVersion && maxVersion <= MAX_VERSION) || mask < -1 || mask > 7) throw new RangeError("Invalid value");
+	let version;
+	let dataUsedBits;
+	for (version = minVersion;; version++) {
+		const dataCapacityBits2 = getNumDataCodewords(version, ecl) * 8;
+		const usedBits = getTotalBits(segs, version);
+		if (usedBits <= dataCapacityBits2) {
+			dataUsedBits = usedBits;
+			break;
+		}
+		if (version >= maxVersion) throw new RangeError("Data too long");
+	}
+	for (const newEcl of [
+		MEDIUM,
+		QUARTILE,
+		HIGH
+	]) if (boostEcl && dataUsedBits <= getNumDataCodewords(version, newEcl) * 8) ecl = newEcl;
+	const bb = [];
+	for (const seg of segs) {
+		appendBits(seg.mode[0], 4, bb);
+		appendBits(seg.numChars, numCharCountBits(seg.mode, version), bb);
+		for (const b of seg.getData()) bb.push(b);
+	}
+	const dataCapacityBits = getNumDataCodewords(version, ecl) * 8;
+	appendBits(0, Math.min(4, dataCapacityBits - bb.length), bb);
+	appendBits(0, (8 - bb.length % 8) % 8, bb);
+	for (let padByte = 236; bb.length < dataCapacityBits; padByte ^= 253) appendBits(padByte, 8, bb);
+	const dataCodewords = Array.from({ length: Math.ceil(bb.length / 8) }, () => 0);
+	bb.forEach((b, i) => dataCodewords[i >>> 3] |= b << 7 - (i & 7));
+	return new QrCode(version, ecl, dataCodewords, mask);
+}
+function encode(data, options) {
+	const { ecc = "L", boostEcc = false, minVersion = 1, maxVersion = 40, maskPattern = -1, border = 1 } = options || {};
+	const segment = typeof data === "string" ? makeSegments(data) : Array.isArray(data) ? [makeBytes(data)] : void 0;
+	if (!segment) throw new Error(`uqr only supports encoding string and binary data, but got: ${typeof data}`);
+	const qr = encodeSegments(segment, EccMap[ecc], minVersion, maxVersion, maskPattern, boostEcc);
+	const result = addBorder({
+		version: qr.version,
+		maskPattern: qr.mask,
+		size: qr.size,
+		data: qr.modules,
+		types: qr.types
+	}, border);
+	if (options?.invert) result.data = result.data.map((row) => row.map((mod) => !mod));
+	options?.onEncoded?.(result);
+	return result;
+}
+function addBorder(input, border = 1) {
+	if (!border) return input;
+	const { size } = input;
+	const newSize = size + border * 2;
+	input.size = newSize;
+	input.data.forEach((row) => {
+		for (let i = 0; i < border; i++) {
+			row.unshift(false);
+			row.push(false);
+		}
+	});
+	for (let i = 0; i < border; i++) {
+		input.data.unshift(Array.from({ length: newSize }, (_) => false));
+		input.data.push(Array.from({ length: newSize }, (_) => false));
+	}
+	const b = QrCodeDataType.Border;
+	input.types.forEach((row) => {
+		for (let i = 0; i < border; i++) {
+			row.unshift(b);
+			row.push(b);
+		}
+	});
+	for (let i = 0; i < border; i++) {
+		input.types.unshift(Array.from({ length: newSize }, (_) => b));
+		input.types.push(Array.from({ length: newSize }, (_) => b));
+	}
+	return input;
+}
+function escapeAttr(value) {
+	return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function renderSVG(data, options = {}) {
+	const result = encode(data, options);
+	const { pixelSize = 10, whiteColor = "white", blackColor = "black" } = options;
+	const height = result.size * pixelSize;
+	const width = result.size * pixelSize;
+	let svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${width} ${height}">`;
+	const paths = [];
+	for (let row = 0; row < result.size; row++) for (let col = 0; col < result.size; col++) {
+		const x = col * pixelSize;
+		const y = row * pixelSize;
+		if (result.data[row][col]) paths.push(`M${x},${y}h${pixelSize}v${pixelSize}h-${pixelSize}z`);
+	}
+	svg += `<rect fill="${escapeAttr(whiteColor)}" width="${width}" height="${height}"/>`;
+	svg += `<path fill="${escapeAttr(blackColor)}" d="${paths.join("")}"/>`;
+	svg += "</svg>";
+	return svg;
+}
+//#endregion
+//#region src/routes/api/connections/pairing/+server.ts
+/** Max device-label length (PR #564 r3566891768). Keeps the pairing code well
+*  under a QR code's byte capacity so renderSVG cannot throw after minting. */
+var MAX_PAIRING_LABEL_LENGTH = 64;
+/** Warnings named in the panel copy so the operator knows exactly which env
+*  keys / prerequisites this pairing code depends on (D3 risk 6: the pairing
+*  endpoint never mutates stack env implicitly — it only tells the operator
+*  what to set). */
+function computeWarnings(mergedEnv, targetUrl) {
+	const warnings = [];
+	if (mergedEnv.GUARDIAN_DIRECT_INGRESS !== "true") warnings.push("GUARDIAN_DIRECT_INGRESS is not enabled on this stack — set it to true in stack.env and restart the guardian, or this connection will 404.");
+	try {
+		const parsed = new URL(targetUrl);
+		if (parsed.protocol === "http:" && !isLoopback(parsed.hostname)) warnings.push("This URL is plain HTTP, not HTTPS, and not loopback — phones and hosted clients refuse plain-HTTP remote connections. See docs/remote-access-tls.md.");
+	} catch {}
+	return warnings;
+}
+var POST = async (event) => {
+	const capabilityError = requireCapability(event, "host:stack:write", getRequestId(event));
+	if (capabilityError) return capabilityError;
+	return withAdminBody(event, async ({ requestId, body }) => {
+		const label = typeof body.label === "string" ? body.label.trim() : "";
+		const rawUrl = typeof body.url === "string" ? body.url : "";
+		if (!label) return errorResponse(400, "invalid_connection", "label is required", {}, requestId);
+		if (label.length > MAX_PAIRING_LABEL_LENGTH) return errorResponse(400, "invalid_connection", `label must be at most ${MAX_PAIRING_LABEL_LENGTH} characters`, {}, requestId);
+		const urlCheck = validateEndpointUrl(rawUrl);
+		if (!urlCheck.ok) return errorResponse(400, "invalid_connection", "URL must be a valid http(s) URL", {}, requestId);
+		const homeDir = getState().homeDir;
+		const mergedEnv = {
+			...readStackRuntimeEnv(homeDir),
+			...process.env
+		};
+		const guardianAdminUrl = `http://127.0.0.1:${Number(mergedEnv.OP_GUARDIAN_ADMIN_PORT) || 3831}`;
+		const result = await mintDirectPrincipalPairingCode({
+			homeDir,
+			label,
+			url: urlCheck.url,
+			guardianAdminUrl
+		});
+		if (!result.ok) {
+			if (result.error.includes("op_guardian_admin_token")) return errorResponse(500, "pairing_mint_failed", result.error, {}, requestId);
+			return errorResponse(502, "pairing_mint_failed", result.error, {}, requestId);
+		}
+		const warnings = computeWarnings(mergedEnv, urlCheck.url);
+		let qrSvg = null;
+		try {
+			qrSvg = renderSVG(result.code);
+		} catch {
+			qrSvg = null;
+		}
+		return jsonResponse(201, {
+			code: result.code,
+			principalId: result.principalId,
+			qrSvg,
+			warnings
+		}, requestId);
+	});
+};
+
+export { POST };
+//# sourceMappingURL=_server.ts-B6IuU4lX.js.map