@deslop/opm 0.1.1241 → 0.1.1243

package/dist/server.js

@@ -3427,6 +3427,8 @@ const SuccessImpl = function(success) {
 SuccessImpl.prototype = SuccessProto;
 /** @internal */
 const succeed$10 = (success) => new SuccessImpl(success);
+/** @internal */
+const getSuccess$1 = (self) => isFailure$2(self) ? none$1 : some$3(self.success);
 // ../../node_modules/.pnpm/effect@4.1.2/node_modules/effect/dist/Order.js
 /**
 * Defines comparison functions for ordered values.
@@ -5351,6 +5353,37 @@ const isFailure$1 = isFailure$2;
 */
 const isSuccess$1 = isSuccess$2;
 /**
+* Extracts the success value as an `Option`, discarding the failure.
+*
+* **When to use**
+*
+* Use when you need to extract the success value from a `Result` as an
+* `Option` and discard failure information.
+*
+* **Details**
+*
+* - `Success<A>` becomes `Some<A>`
+* - `Failure<E>` becomes `None`
+*
+* **Example** (Extracting the success as an Option)
+*
+* ```ts import.meta.vitest
+* import { Option, Result } from "effect"
+*
+* Result.getSuccess(Result.succeed("ok")) // => Option.some("ok")
+*
+* Result.getSuccess(Result.fail("err")) // => Option.none()
+* ```
+*
+* @see {@link getFailure} to extract the error instead
+* @see {@link fromOption} for the reverse conversion
+*
+* @stability stable
+* @category getters
+* @since 4.0.0
+*/
+const getSuccess = getSuccess$1;
+/**
 * Transforms the success channel of a `Result`, leaving the failure channel unchanged.
 *
 * **When to use**
@@ -5994,7 +6027,7 @@ const makeEquivalence$2 = (equivalence) => {
 * @category constructors
 * @since 4.0.0
 */
-const Array$1 = globalThis.Array;
+const Array$2 = globalThis.Array;
 /**
 * Converts an `Iterable` to an `Array`.
 *
@@ -6023,7 +6056,7 @@ const Array$1 = globalThis.Array;
 * @category constructors
 * @since 2.0.0
 */
-const fromIterable$6 = (collection) => Array$1.isArray(collection) ? collection : Array$1.from(collection);
+const fromIterable$6 = (collection) => Array$2.isArray(collection) ? collection : Array$2.from(collection);
 /**
 * Normalizes a value that is either a single element or an array into an array.
 *
@@ -6054,7 +6087,7 @@ const fromIterable$6 = (collection) => Array$1.isArray(collection) ? collection
 * @category constructors
 * @since 3.3.0
 */
-const ensure = (self) => Array$1.isArray(self) ? self : [self];
+const ensure = (self) => Array$2.isArray(self) ? self : [self];
 /**
 * Pattern-matches on an array, handling empty and non-empty cases separately.
 *
@@ -6167,7 +6200,7 @@ const append$3 = /*#__PURE__*/ dual(2, (self, last) => [...self, last]);
 * @category guards
 * @since 2.0.0
 */
-const isArray = Array$1.isArray;
+const isArray = Array$2.isArray;
 /**
 * Checks whether a mutable `Array` is empty, narrowing the type to `[]`.
 *
@@ -6518,7 +6551,7 @@ const findLast = /*#__PURE__*/ dual(2, (self, f) => {
 * @category transforming
 * @since 2.0.0
 */
-const reverse = (self) => Array$1.from(self).reverse();
+const reverse = (self) => Array$2.from(self).reverse();
 /**
 * Sorts an array by the given `Order`, returning a new array.
 *
@@ -6547,7 +6580,7 @@ const reverse = (self) => Array$1.from(self).reverse();
 * @since 2.0.0
 */
 const sort = /*#__PURE__*/ dual(2, (self, O) => {
-	const out = Array$1.from(self);
+	const out = Array$2.from(self);
 	out.sort(O);
 	return out;
 });
@@ -6869,6 +6902,50 @@ const hashBucketsAdd = (buckets, value) => {
 	bucket.push(value);
 	return true;
 };
+const makeHashBuckets = (values) => {
+	const buckets = /* @__PURE__ */ new Map();
+	for (const value of values) hashBucketsAdd(buckets, value);
+	return buckets;
+};
+const hashBucketsHas = (buckets, value) => {
+	const bucket = buckets.get(hash(value));
+	if (bucket === void 0) return false;
+	for (const candidate of bucket) if (equals$1(candidate, value)) return true;
+	return false;
+};
+/**
+* Computes elements in the first array that are not in the second, using
+* `Equal.asEquivalence()`.
+*
+* **When to use**
+*
+* Use when you need to keep values from the first array that are absent from
+* the second and the default `Equal.asEquivalence()` comparison is appropriate.
+*
+* **Example** (Computing array differences)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.difference([1, 2, 3], [2, 3, 4]) // => [1]
+* ```
+*
+* @see {@link differenceWith} — use custom equality
+* @see {@link union} — elements in either array
+* @see {@link intersection} — elements in both arrays
+*
+* @stability stable
+* @category set operations
+* @since 2.0.0
+*/
+const difference = /*#__PURE__*/ dual(2, (self, that) => {
+	const thatArray = fromIterable$6(that);
+	const selfArray = fromIterable$6(self);
+	if (selfArray.length === 0) return [];
+	if (thatArray.length === 0) return selfArray.filter(() => true);
+	const buckets = makeHashBuckets(thatArray);
+	return selfArray.filter((value) => !hashBucketsHas(buckets, value));
+});
 /**
 * Creates an empty array.
 *
@@ -14930,7 +15007,7 @@ const isNonEmpty$1 = (self) => self.length > 0;
 * @category transforming
 * @since 2.0.0
 */
-const split = /*#__PURE__*/ dual(2, (self, separator) => {
+const split$1 = /*#__PURE__*/ dual(2, (self, separator) => {
 	const out = self.split(separator);
 	return isArrayNonEmpty$1(out) ? out : [self];
 });
@@ -25425,7 +25502,7 @@ const encode = (input) => encodeBytes(typeof input === "string" ? encoder$4.enco
 * @category decoding
 * @since 4.0.0
 */
-const decode = (str) => {
+const decode$1 = (str) => {
 	const stripped = stripCrlf(str);
 	const length = stripped.length;
 	if (length % 4 !== 0) return fail$11(new EncodingError({
@@ -25471,20 +25548,20 @@ const encodeShort = (bytes) => {
 	let result = "";
 	let i = 2;
 	for (; i < length; i += 3) {
-		result += alphabet[bytes[i - 2] >> 2];
-		result += alphabet[(bytes[i - 2] & 3) << 4 | bytes[i - 1] >> 4];
-		result += alphabet[(bytes[i - 1] & 15) << 2 | bytes[i] >> 6];
-		result += alphabet[bytes[i] & 63];
+		result += alphabet$1[bytes[i - 2] >> 2];
+		result += alphabet$1[(bytes[i - 2] & 3) << 4 | bytes[i - 1] >> 4];
+		result += alphabet$1[(bytes[i - 1] & 15) << 2 | bytes[i] >> 6];
+		result += alphabet$1[bytes[i] & 63];
 	}
 	if (i === length + 1) {
-		result += alphabet[bytes[i - 2] >> 2];
-		result += alphabet[(bytes[i - 2] & 3) << 4];
+		result += alphabet$1[bytes[i - 2] >> 2];
+		result += alphabet$1[(bytes[i - 2] & 3) << 4];
 		result += "==";
 	}
 	if (i === length) {
-		result += alphabet[bytes[i - 2] >> 2];
-		result += alphabet[(bytes[i - 2] & 3) << 4 | bytes[i - 1] >> 4];
-		result += alphabet[(bytes[i - 1] & 15) << 2];
+		result += alphabet$1[bytes[i - 2] >> 2];
+		result += alphabet$1[(bytes[i - 2] & 3) << 4 | bytes[i - 1] >> 4];
+		result += alphabet$1[(bytes[i - 1] & 15) << 2];
 		result += "=";
 	}
 	return result;
@@ -25512,21 +25589,123 @@ const encodeLong = (bytes) => {
 		result[j + 2] = alphabetCodes[(bytes[i - 1] & 15) << 2];
 		result[j + 3] = paddingCode;
 	}
-	return decoder.decode(result);
+	return decoder$1.decode(result);
 };
 const encoder$4 = /*#__PURE__*/ new TextEncoder();
-const decoder = /*#__PURE__*/ new TextDecoder();
+const decoder$1 = /*#__PURE__*/ new TextDecoder();
 const stripCrlf = (str) => str.replace(/[\n\r]/g, "");
-const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-const alphabetCodes = /*#__PURE__*/ encoder$4.encode(alphabet);
+const alphabet$1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const alphabetCodes = /*#__PURE__*/ encoder$4.encode(alphabet$1);
 const paddingCode = /*#__PURE__*/ "=".charCodeAt(0);
-const codes = /*#__PURE__*/ (/* @__PURE__ */ new Uint8Array(123)).fill(255);
-for (let i = 0; i < 64; i++) codes[/*#__PURE__*/ alphabet.charCodeAt(i)] = i;
-codes[/*#__PURE__*/ "=".charCodeAt(0)] = 0;
+const codes$1 = /*#__PURE__*/ (/* @__PURE__ */ new Uint8Array(123)).fill(255);
+for (let i = 0; i < 64; i++) codes$1[/*#__PURE__*/ alphabet$1.charCodeAt(i)] = i;
+codes$1[/*#__PURE__*/ "=".charCodeAt(0)] = 0;
 const getCode = (charCode) => {
-	if (charCode >= codes.length || codes[charCode] === 255) throw new TypeError(`Invalid character ${String.fromCharCode(charCode)}`);
-	return codes[charCode];
+	if (charCode >= codes$1.length || codes$1[charCode] === 255) throw new TypeError(`Invalid character ${String.fromCharCode(charCode)}`);
+	return codes$1[charCode];
 };
+// ../../node_modules/.pnpm/effect@4.1.2/node_modules/effect/dist/encoding/Base64Url.js
+/**
+* URL-safe Base64 encoding and decoding helpers.
+*
+* @stability stable
+* @since 4.0.0
+*/
+/**
+* Decodes a padded or unpadded URL-safe Base64 string into bytes safely.
+*
+* **When to use**
+*
+* Use to decode Base64Url text into bytes without throwing on invalid input.
+*
+* **Details**
+*
+* Returns `Result.succeed` with a `Uint8Array` when decoding succeeds, or
+* `Result.fail` with an `EncodingError` when the input is not valid
+* Base64Url. Both padded and unpadded forms are accepted when otherwise valid.
+*
+* **Example** (Decoding URL-safe Base64 bytes)
+*
+* ```ts import.meta.vitest
+* import { Result } from "effect"
+* import { Base64Url } from "effect/encoding"
+*
+* Base64Url.decode("SGVsbG8_") // => Result.succeed(new Uint8Array([72, 101, 108, 108, 111, 63]))
+* ```
+*
+* @stability stable
+* @category decoding
+* @since 4.0.0
+*/
+const decode = (str) => {
+	const stripped = str.replace(/[\n\r]/g, "");
+	const length = stripped.length;
+	const padded = stripped.endsWith("=");
+	if (padded ? length % 4 !== 0 : length % 4 === 1) return fail$11(new EncodingError({
+		module: "Base64Url",
+		kind: "Decode",
+		input: stripped,
+		message: padded ? `Padded length should be a multiple of 4, but is ${length}` : `Unpadded length should not be 1 more than a multiple of 4, but is ${length}`
+	}));
+	if (!/^[-_A-Z0-9]*?={0,2}$/i.test(stripped)) return fail$11(new EncodingError({
+		module: "Base64Url",
+		kind: "Decode",
+		input: stripped,
+		message: "Invalid input"
+	}));
+	const end = !padded ? length : stripped.charCodeAt(length - 2) === 61 ? length - 2 : length - 1;
+	const fullEnd = end & -4;
+	const result = new Uint8Array(Math.floor(end * 3 / 4));
+	let j = 0;
+	for (let i = 0; i < fullEnd; i += 4) {
+		const a = codes[stripped.charCodeAt(i)];
+		const b = codes[stripped.charCodeAt(i + 1)];
+		const c = codes[stripped.charCodeAt(i + 2)];
+		const d = codes[stripped.charCodeAt(i + 3)];
+		result[j++] = a << 2 | b >> 4;
+		result[j++] = b << 4 | c >> 2;
+		result[j++] = c << 6 | d;
+	}
+	if (end > fullEnd) {
+		const a = codes[stripped.charCodeAt(fullEnd)];
+		const b = codes[stripped.charCodeAt(fullEnd + 1)];
+		result[j++] = a << 2 | b >> 4;
+		if (end - fullEnd === 3) result[j] = b << 4 | codes[stripped.charCodeAt(fullEnd + 2)] >> 2;
+	}
+	return succeed$9(result);
+};
+const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+const codes = /*#__PURE__*/ new Uint8Array(128);
+for (let i = 0; i < 64; i++) codes[/*#__PURE__*/ alphabet.charCodeAt(i)] = i;
+/**
+* Decodes a padded or unpadded URL-safe Base64 string into UTF-8 text safely.
+*
+* **When to use**
+*
+* Use to decode Base64Url text into UTF-8 text without throwing on invalid
+* input.
+*
+* **Details**
+*
+* Returns `Result.succeed` with the decoded text when decoding succeeds, or
+* `Result.fail` with an `EncodingError` when the input is not valid
+* Base64Url.
+*
+* **Example** (Decoding URL-safe Base64 strings)
+*
+* ```ts import.meta.vitest
+* import { Result } from "effect"
+* import { Base64Url } from "effect/encoding"
+*
+* Base64Url.decodeString("aGVsbG8_") // => Result.succeed("hello?")
+* ```
+*
+* @stability stable
+* @category decoding
+* @since 4.0.0
+*/
+const decodeString$1 = (str) => map$11(decode(str), (_) => decoder.decode(_));
+const decoder = /*#__PURE__*/ new TextDecoder();
 /**
 * SHA-1, with a 20-byte output.
 *
@@ -29373,6 +29552,39 @@ function joinKeyValue(options) {
 	return transform$2((input) => Object.entries(input).map(([key, value]) => `${key}${keyValueSeparator}${value}`).join(separator));
 }
 /**
+* Splits a string into an array of strings by a separator.
+*
+* **When to use**
+*
+* Use when you need a schema getter to split a present encoded string
+* containing a delimited list, such as CSV values.
+*
+* **Details**
+*
+* The getter is pure and never fails. It splits by `separator` (default `,`).
+* An empty string produces an empty array, not `[""]`.
+*
+* **Example** (Splitting a comma-separated string)
+*
+* ```ts import.meta.vitest
+* import { Effect, Option, SchemaGetter } from "effect"
+*
+* const splitComma = SchemaGetter.split<string>()
+* const result = Effect.runSync(SchemaGetter.run(splitComma, Option.some("a,b,c"), {}))
+* result // => Option.some(["a", "b", "c"])
+* ```
+*
+* @see {@link splitKeyValue} when values are key-value pairs
+*
+* @stability stable
+* @category splitting
+* @since 4.0.0
+*/
+function split(options) {
+	const separator = options?.separator ?? ",";
+	return transform$2((input) => input === "" ? [] : input.split(separator));
+}
+/**
 * Encodes a `Uint8Array` or string to a Base64 string.
 *
 * **Details**
@@ -29425,7 +29637,7 @@ function encodeBase64() {
 * @since 4.0.0
 */
 function decodeBase64$1() {
-	return transformEffect$1((input, options) => mapErrorEager(fromResult(decode(input)), () => new InvalidValue$1({ expected: "a valid Base64 string" }, input, options)));
+	return transformEffect$1((input, options) => mapErrorEager(fromResult(decode$1(input)), () => new InvalidValue$1({ expected: "a valid Base64 string" }, input, options)));
 }
 /**
 * Encodes a present string using `encodeURIComponent`.
@@ -42077,6 +42289,16 @@ function succeed$1(value) {
 function String$5(name) {
 	return schema$1(String$6, name);
 }
+function Array$1(value, pathOrOptions, options) {
+	const hasPath = isPath(pathOrOptions);
+	const resolvedOptions = hasPath ? options : pathOrOptions;
+	const array = ArraySchema(value);
+	const separator = resolvedOptions?.separator ?? ",";
+	return schema$1(Union([String$6.pipe(decodeTo(toCodecStringTree(array), {
+		decode: split(resolvedOptions),
+		encode: compose(passthrough$1({ strict: false }), transform$2((input) => input.join(separator)))
+	})), array]), hasPath ? pathOrOptions : void 0);
+}
 function Record(key, value, pathOrOptions, options) {
 	const hasPath = isPath(pathOrOptions);
 	const record = Record$1(key, value);
@@ -44575,6 +44797,17 @@ const updateContentLength = (headers, body) => {
 };
 // ../../node_modules/.pnpm/effect@4.1.2/node_modules/effect/dist/http/Url.js
 /**
+* Parses and edits platform `URL` values.
+*
+* The HTTP modules use the standard `URL` object as their URL representation.
+* This module adds safe parsing and helpers that return updated copies when
+* changing credentials, host, path, protocol, query, or hash parts. Query
+* strings can also be read or updated through `UrlParams`.
+*
+* @stability unstable
+* @since 4.0.0
+*/
+/**
 * Error returned when constructing a `URL` fails.
 *
 * @stability unstable
@@ -44615,6 +44848,51 @@ const baseUrl = () => {
 		}
 	}
 };
+/**
+* Parses a URL string safely into a `URL` object, returning a `Result` type for
+* error handling.
+*
+* **Details**
+*
+* This function converts a string into a `URL` object, enabling safe URL
+* parsing with built-in error handling. If the string is invalid or fails to
+* parse, this function does not throw an error; instead, it wraps the error in
+* a `IllegalArgumentError` and returns it as the `Failure` value of an
+* `Result`. The `Success` value contains the successfully parsed `URL`.
+*
+* An optional `base` parameter can be provided to resolve relative URLs. If
+* specified, the function interprets the input `url` as relative to this
+* `base`. This is especially useful when dealing with URLs that might not be
+* fully qualified.
+*
+* **Example** (Parsing absolute and relative URLs)
+*
+* ```ts import.meta.vitest
+* import { Result } from "effect"
+* import { Url } from "effect/http"
+*
+* // Parse an absolute URL
+* //
+* //      ┌─── Result<URL, IllegalArgumentError>
+* //      ▼
+* const parsed = Url.fromString("https://example.com/path")
+*
+* Result.map(parsed, (url) => url.toString()) // => Result.succeed("https://example.com/path")
+*
+* // Parse a relative URL with a base
+* const relativeParsed = Url.fromString("/relative-path", "https://example.com")
+*
+* Result.map(relativeParsed, (url) => url.toString()) // => Result.succeed("https://example.com/relative-path")
+* ```
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const fromString = (url, base) => try_$2({
+	try: () => new URL(url, base),
+	catch: () => new IllegalArgumentError(`Invalid URL: "${url}"${base !== void 0 ? ` with base "${base}"` : ""}`)
+});
 // ../../node_modules/.pnpm/effect@4.1.2/node_modules/effect/dist/http/HttpClientRequest.js
 const TypeId$15 = "~effect/http/HttpClientRequest";
 /**
@@ -70922,32 +71200,23 @@ Struct({
 	expires_in: Finite,
 	refresh_token: NonEmptyString
 });
-const Origin = String$6.check(makeFilter((value) => {
-	if (!URL.canParse(value)) return false;
-	const url = new URL(value);
-	return contains$1(["http:", "https:"], url.protocol) && url.username === "" && url.password === "" && url.hash === "";
-}, { expected: "an HTTP(S) URL without credentials or a fragment" })).check(makeFilter((value) => {
-	if (!URL.canParse(value)) return false;
-	const url = new URL(value);
-	return url.pathname === "/" && url.search === "";
-}, { expected: "an HTTP(S) origin without a path or query" }));
-const SecureOrigin = Origin.check(makeFilter((value) => {
-	if (!URL.canParse(value)) return false;
-	const url = new URL(value);
-	return url.protocol === "https:" || contains$1([
-		"localhost",
-		"127.0.0.1",
-		"[::1]"
-	], url.hostname);
-}, { expected: "HTTPS outside loopback" }));
+const Origin = String$6.check(makeFilter((value) => exists(getSuccess(fromString(value)), (url) => contains$1(["http:", "https:"], url.protocol) && url.username === "" && url.password === "" && url.hash === ""), { expected: "an HTTP(S) URL without credentials or a fragment" })).check(makeFilter((value) => exists(getSuccess(fromString(value)), (url) => url.pathname === "/" && url.search === ""), { expected: "an HTTP(S) origin without a path or query" }));
+const SecureOrigin = Origin.check(makeFilter((value) => exists(getSuccess(fromString(value)), (url) => url.protocol === "https:" || contains$1([
+	"localhost",
+	"127.0.0.1",
+	"[::1]"
+], url.hostname)), { expected: "HTTPS outside loopback" }));
 const Port = String$6.check(isPattern(/^\d{1,5}$/u), makeFilter((value) => exists(parse$9(value), (port) => port >= 1 && port <= 65535), { expected: "a port between 1 and 65535" }));
 const AppVersion = String$6.check(isPattern(/^0\.1\.\d+$/u));
+const RUNTIME_PATH = "/api/runtime";
 const RuntimeConfig = Struct({
 	auth: optionalKey(String$6),
 	name: String$6,
 	traces: String$6,
 	version: AppVersion
 });
+const RPC_PATH = "/api/rpc";
+const MANIFEST_PATH = "/manifest.webmanifest";
 const Account = Struct({
 	...User.fields,
 	signOut: Boolean$5
@@ -71664,11 +71933,19 @@ function layerOtlp(serviceName, url, runtime, version) {
 	}));
 }
 // ../../packages/runtime/src/auth/lib/utils.ts
+const APPS_PATH = "/api/apps";
+const SESSION_PATH = "/auth/session";
+const VERIFY_PATH = "/auth/verify";
 const DEVELOPER = {
 	id: "github:0",
 	name: "dev"
 };
 const localAuth = map$3(option(String$5("AUTH_URL")), isNone);
+gen(function* () {
+	const listed = Array$1(String$6, "GITHUB_ADMINS");
+	if (yield* localAuth) return yield* withDefault$2(listed, ["0"]);
+	return yield* listed;
+});
 var CurrentUser = class extends Service$1()("@deslop/runtime/auth/lib/utils/CurrentUser") {};
 var RpcAuth = class RpcAuth extends Service()("@deslop/runtime/auth/lib/utils/RpcAuth", { error: AuthError }) {
 	static layerClient = (token) => layerClient(RpcAuth, (options) => gen(function* () {
@@ -71711,7 +71988,7 @@ var Auth = class Auth extends Service$1()("@deslop/runtime/auth/service/Auth") {
 		const canonical = new URL(yield* String$5("APP_URL")).origin;
 		const client = filterStatusOk(yield* HttpClient);
 		const access = fn("Auth.access")(function* (headers, audience) {
-			return yield* pipe(client.get(new URL("/auth/verify", issuer).href, {
+			return yield* pipe(client.get(new URL(VERIFY_PATH, issuer).href, {
 				headers: { authorization: headers["authorization"] ?? "" },
 				urlParams: { resource: audience }
 			}), flatMap$3(schemaBodyJson(User)), timeout("10 seconds"));
@@ -71720,7 +71997,7 @@ var Auth = class Auth extends Service$1()("@deslop/runtime/auth/service/Auth") {
 			access,
 			user: fn("Auth.user")(function* (headers) {
 				if (isSome(get$6(headers, "authorization"))) return yield* access(headers, canonical);
-				return yield* pipe(client.get(new URL("/auth/session", issuer).href, { headers: { cookie: headers["cookie"] ?? "" } }), flatMap$3(schemaBodyJson(User)), timeout("10 seconds"));
+				return yield* pipe(client.get(new URL(SESSION_PATH, issuer).href, { headers: { cookie: headers["cookie"] ?? "" } }), flatMap$3(schemaBodyJson(User)), timeout("10 seconds"));
 			}, rejected("Sign in first"))
 		}));
 	}));
@@ -71792,7 +72069,7 @@ const guard = make$17((app) => gen(function* () {
 		const canonical = new URL(yield* String$5("APP_URL")).hostname;
 		if (!exists(liftThrowable(() => new URL(`http://${host}`))(), (url) => url.hostname === canonical || isSome(match$3(LOOPBACK)(url.hostname)))) return empty$1({ status: 403 });
 	}
-	if (exists(origin, (value) => !exists(liftThrowable(() => new URL(value).host)(), (originHost) => originHost === host)) && request.headers["sec-fetch-site"] !== "same-origin" && !contains$1(OTLP, headNonEmpty(split(request.url, "?")))) return empty$1({ status: 403 });
+	if (exists(origin, (value) => !exists(liftThrowable(() => new URL(value).host)(), (originHost) => originHost === host)) && request.headers["sec-fetch-site"] !== "same-origin" && !contains$1(OTLP, headNonEmpty(split$1(request.url, "?")))) return empty$1({ status: 403 });
 	return yield* app;
 }));
 function layerKeyValueStore(directory) {
@@ -71855,7 +72132,7 @@ const layerRoutes = use((router) => gen(function* () {
 			})
 		});
 	});
-	yield* router.add("GET", "/api/runtime", gen(function* () {
+	yield* router.add("GET", RUNTIME_PATH, gen(function* () {
 		return yield* schemaJson(RuntimeConfig)({
 			...match$8(issuer, {
 				onNone: () => ({}),
@@ -71883,7 +72160,7 @@ const layerAnnounce = effectDiscard(gen(function* () {
 	yield* match$8(yield* option(String$5("AUTH_URL")), {
 		onNone: () => void_$1,
 		onSome: fnUntraced(function* (issuer) {
-			yield* pipe(post(new URL("/api/apps", issuer).href), bodyJsonUnsafe({ origin }), client.execute, delay("2 seconds"), retry({
+			yield* pipe(post(new URL(APPS_PATH, issuer).href), bodyJsonUnsafe({ origin }), client.execute, delay("2 seconds"), retry({
 				schedule: spaced("1 minute"),
 				times: 60
 			}), ignore$1({
@@ -71904,7 +72181,7 @@ const layerWeb = unwrap$8(gen(function* () {
 	const client = fileURLToPath(new URL("./client", import.meta.url));
 	if (!(yield* (yield* FileSystem).exists((yield* Path$1).join(client, "index.html")))) return empty$10;
 	const name = capitalize(yield* appName);
-	return mergeAll$1(add$1("GET", "/manifest.webmanifest", succeed$5(jsonUnsafe({
+	return mergeAll$1(add$1("GET", MANIFEST_PATH, succeed$5(jsonUnsafe({
 		background_color: "#0a0a0a",
 		display: "standalone",
 		icons: [{
@@ -71933,6 +72210,14 @@ const layerWeb = unwrap$8(gen(function* () {
 		spa: true
 	}));
 }));
+function layerRpc(options) {
+	return pipe(layerHttp({
+		disableTracing: options.disableTracing,
+		group: options.group,
+		path: RPC_PATH,
+		protocol: "websocket"
+	}), provide$2(options.handlers));
+}
 const layerNodeHttpServer = layerConfig(createServer, {
 	gracefulShutdownTimeout: succeed$1("1500 millis"),
 	host: String$5("HOST"),
@@ -72055,7 +72340,7 @@ const update$1 = fnUntraced(function* (name) {
 	yield* activate(name, path.join(directory, "node_modules", "@deslop", name));
 	yield* restart(name);
 	const kept = [latest, ...toArray$1(map$12(previous, (link) => path.basename(path.resolve(link, "../../.."))))];
-	yield* forEach$1(filter$4(yield* fs.readDirectory(path.join(root, "releases")), (entry) => !contains$1(kept, entry)), (entry) => fs.remove(path.join(root, "releases", entry), { recursive: true }), { concurrency: 1 });
+	yield* forEach$1(difference(yield* fs.readDirectory(path.join(root, "releases")), kept), (entry) => fs.remove(path.join(root, "releases", entry), { recursive: true }), { concurrency: 1 });
 	return `Updated ${name} from ${running} to ${latest}\n`;
 });
 // ../../packages/runtime/src/cli.ts
@@ -118743,7 +119028,7 @@ function seriesOf(link) {
 function unwrapped(link) {
 	return match$8(fromNullishOr(WRAPPED.exec(link)?.groups?.["encoded"]), {
 		onNone: () => some$2(link),
-		onSome: (encoded) => pipe(liftThrowable(atob)(replaceAll("_", "/")(replaceAll("-", "+")(encoded))), filter$5(startsWith("https://")))
+		onSome: (encoded) => pipe(getSuccess(decodeString$1(encoded)), filter$5(startsWith("https://")))
 	});
 }
 function pageLink(page) {
@@ -119025,22 +119310,19 @@ var Chapters = class Chapters extends Service$1()("@deslop/opm/services/chapters
 	}));
 };
 const layerChapters = unwrap$8(pipe(dataDirectory, failed("The chapters folder could not be read."), map$6(Chapters.layer)));
-// src/rpcs/handlers.ts
-const RpcHandlers = RpcContracts.toLayer(gen(function* () {
-	const chapters = yield* Chapters;
-	return RpcContracts.of({
-		"chapters.read": (input) => chapters.read(input),
-		"devices.register": (input) => chapters.register(input.token),
-		"library.watch": () => chapters.changes
-	});
-}));
 // src/main.server.ts
 runApp({
 	icon: icon_default,
-	routes: pipe(layerHttp({
+	routes: pipe(layerRpc({
 		group: RpcContracts,
-		path: "/api/rpc",
-		protocol: "websocket"
-	}), provide$2(RpcHandlers), provide$2(layerJson$1), provide$2(layerChapters))
+		handlers: RpcContracts.toLayer(gen(function* () {
+			const chapters = yield* Chapters;
+			return RpcContracts.of({
+				"chapters.read": (input) => chapters.read(input),
+				"devices.register": (input) => chapters.register(input.token),
+				"library.watch": () => chapters.changes
+			});
+		}))
+	}), provide$2(layerJson$1), provide$2(layerChapters))
 });
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@deslop/opm",
-	"version": "0.1.1241",
+	"version": "0.1.1243",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/MP281X/deslop.git",
@@ -31,5 +31,5 @@
 	"engines": {
 		"node": ">=26"
 	},
-	"fingerprint": "f4300b4832ff540cc4bbd1345db8a58e816533a9d837e5f0eea408b08968b3b2"
+	"fingerprint": "b1d8f9413ddc6ed22339d49b52604e6a217b46691bb3faf979f4d3b8faafd457"
 }