@deslop/stash 0.1.1092 → 0.1.1095

package/README.md

@@ -7,4 +7,4 @@ vpx @deslop/stash@latest login '<api key>'
 vpx @deslop/stash@latest save '<link or text>' [--server <url>]
 ```
 
-`login` keeps an API key created at https://auth.mp281x.xyz in `~/.config/stash/api-key`.
+`login` keeps an API key created at https://auth.mp281x.xyz in `~/.deslop/stash/api-key`.

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env -S node --max-old-space-size=16384 --heapsnapshot-near-heap-limit=3 --report-on-fatalerror
-import { $d as get, $t as FalseLiterals, Al as squash, B as Terminal, Ba as shutdownUnsafe, Bl as provide$2, Bo as catchFilter, C as AuthError, Cc as whileLoop, Cf as match$1, Cl as hasInterrupts, Cr as fromInput, Ct as makeCollectorUnsafe, Dc as withParentSpan, Df as some, Dn as decodeSync, Dr as merge, Ds as mapError, Dt as SocketErrorReason, Du as sync, Et as SocketError, F as runMain, Fd as isSuccess, Fo as cached, Gs as raceFirst, Gt as BooleanLiterals, Hs as provideContext, I as errorExitCode, Ic as min, Ii as filter$1, In as is, Io as callback, Is as onInterrupt, J as String$7, Jl as addFinalizerExit, Jn as optionalKey, Jo as delay, Kf as format, Kl as Scope, Ko as context, L as errorReported, La as offerAll, Ld as succeed$2, Lo as catchCause, Lt as HttpClientErrorSchema, M as LogToStderr, Mc as exponential, Mr as make$2, Mt as layerWebSocketConstructorGlobal, Na as end, Nr as value, Ns as onError, Os as match$2, Pa as failCause, Pf as Prototype, Pl as effect, Qc as replace, Qd as empty$1, Qo as fail$1, R as layer, Rc as spaced, Rf as withFiber$1, Rl as merge$1, Ro as catchCauseIf, Rs as orDie, Ru as taggedEnum, S as RpcAuth, Sf as map$3, Sr as empty, Ss as logInfo, St as Collector, Ti as FileSystem, Tl as interruptors, Ts as map$2, Tt as Socket, U as Crypto, Uo as catchTag, Us as provideService, Ut as ArraySchema, V as isQuitError, Va as take, Vs as provide$1, Wi as fromQueue, Wo as catchTags, Wu as empty$2, Xa as interrupt$2, Xd as Service, Xf as hasProperty, Xo as ensuring, Xu as findFirstIndex, Ya as getCurrent, Yd as Reference, Yn as tag, Ys as retryOrElse, Yt as Defect, Yu as findFirst, Z as option, Zd as add, Zn as toCodecStringTree, Zs as runForkWith, Zt as Error$1, Zu as findLast, _c as uninterruptibleMask, _f as getOrUndefined, _n as TrueLiterals, _s as isEffect, ac as suspend, as as forEach, at as RpcSerialization, b as AUTH_URL, bc as useSpan, bl as findError, bs as logError, bt as spanAttributes, cc as tapCause, cd as isReadonlyArrayNonEmpty, cf as exists, cl as round, cs as forkIn, da as runHead, dp as dual, du as die, ec as scoped, ep as isNotUndefined, fc as timeoutOrElse, fd as map$4, fs as gen, ft as constPing, fu as fail, gd as reduce, gn as TaggedError, gs as interruptible, gu as isFailure, h as NotesError, hf as getOrElse, hp as pipeArguments, hs as interrupt$1, ht as exitSchema, is as fnUntraced, it as withRunClient, iu as MinimumLogLevel, ja as bounded, jn as encodeEffect, jo as annotateLogs, jt as layerWebSocket, kd as fail$2, kn as decodeUnknownEffect, ko as andThen, ks as matchCauseEffect, kt as SocketReadError, ld as join, lf as filter, ll as Clock, lp as constVoid, ls as forkScoped, lt as RequestId, mf as fromUndefinedOr, mp as pipe, ms as ignoreCause, mu as interrupt, nf as getUnsafe, nt as Stdio, oc as sync$1, os as forever, pd as match, pn as String$6, pp as identity, ps as ignore, pu as failCause$1, qa as makeUnsafe, qc as isNonEmpty, qd as toMillis, ql as addFinalizer, qn as optional$2, qs as result, qu as filter$2, rc as succeed$1, rf as make$3, rn as Literal, sn as NonEmptyArray, st as layerJson, t as RpcContracts, tc as serviceOption, td as getSomes, tf as getOrUndefinedUnsafe, ts as flatMap$1, uc as timeout, vd as some$1, vf as isNone, vt as getStreamSchemas, wc as withFiber, wf as none, wn as Union, ws as makeSpanScoped, xa as unwrap, xc as void_, xt as spanName, yf as isSome, yt as isStreamSchema, yu as ConsoleRef, z as QuitError, zf as assignProperty } from "./contracts-nyOWldn4.mjs";
+import { $ as option, $d as Service, $f as hasProperty, $n as toCodecStringTree, $s as runForkWith, $t as Error$1, $u as findFirstIndex, Af as some, As as match$2, Au as sync, B as layer, Bc as spaced, Bd as succeed$2, Bo as catchCauseIf, Bs as orDie, Ca as unwrap, Cc as void_, Cl as findError, Ct as spanName, Df as none, Di as FileSystem, Ds as map$2, Dt as Socket, Ec as withFiber, Ef as match$1, El as hasInterrupts, En as Union, Es as makeSpanScoped, Fa as end, Fr as value, Fs as onError, G as Crypto, Go as catchTag, Gs as provideService, Gt as ArraySchema, H as Terminal, Ha as shutdownUnsafe, Hf as assignProperty, Ho as catchFilter, Ia as failCause, Jo as context, Ki as fromQueue, Ko as catchTags, L as runMain, Lf as Prototype, Ll as effect, Lo as cached, Md as fail$2, Na as bounded, Nl as squash, Nn as encodeEffect, No as annotateLogs, Nt as layerWebSocket, Ol as interruptors, Ot as SocketError, P as LogToStderr, Pc as exponential, Pr as make$2, Pt as layerWebSocketConstructorGlobal, Qa as interrupt$2, Qd as Reference, Qo as ensuring, Qu as findFirst, R as errorExitCode, Rc as min, Rd as isSuccess, Ri as filter$1, Rn as is, Ro as callback, Rs as onInterrupt, S as RpcAuth, Sc as useSpan, Sf as isSome, Ss as logError, St as spanAttributes, Su as ConsoleRef, Tc as whileLoop, Tf as map$3, Tr as fromInput, Tt as makeCollectorUnsafe, U as isQuitError, Ua as take, Ul as provide$2, Us as provide$1, V as QuitError, Vf as withFiber$1, Vl as merge$1, Vu as taggedEnum, Ws as provideContext, X as String$7, Xd as toMillis, Xl as addFinalizer, Xn as optionalKey, Xo as delay, Xu as filter$2, Ya as makeUnsafe, Yc as isNonEmpty, Yf as format, Yl as Scope, Yn as optional$2, Ys as result, Za as getCurrent, Zl as addFinalizerExit, Zn as tag, Zs as retryOrElse, Zt as Defect, _f as fromUndefinedOr, _p as pipe, _s as interrupt$1, _t as exitSchema, _u as interrupt, ac as succeed$1, af as getUnsafe, an as Literal, b as AUTH_URL, bf as getOrUndefined, bt as getStreamSchemas, cc as sync$1, cs as forever, dd as isReadonlyArrayNonEmpty, df as exists, dl as Clock, ds as forkScoped, dt as RequestId, ed as findLast, ef as add, el as replace, es as fail$1, fc as timeout, fd as join, ff as filter, fp as constVoid, gd as match, gp as identity, gs as ignoreCause, gu as failCause$1, h as NotesError, hd as map$4, hn as String$6, hs as ignore, hu as fail, id as getSomes, if as getOrUndefinedUnsafe, it as Stdio, jn as decodeUnknownEffect, jo as andThen, js as matchCauseEffect, jt as SocketReadError, kc as withParentSpan, kn as decodeSync, kr as merge, ks as mapError, kt as SocketErrorReason, ln as NonEmptyArray, lt as layerJson, mc as timeoutOrElse, mp as dual, ms as gen, mt as constPing, mu as die, nc as scoped, nf as get, of as make$3, os as fnUntraced, ot as withRunClient, pa as runHead, qs as raceFirst, qt as BooleanLiterals, qu as empty$2, rc as serviceOption, rp as isNotUndefined, rs as flatMap$1, sc as suspend, ss as forEach, st as RpcSerialization, su as MinimumLogLevel, t as RpcContracts, tf as empty$1, tn as FalseLiterals, uc as tapCause, ul as round, us as forkIn, vf as getOrElse, vn as TaggedError, vp as pipeArguments, vs as interruptible, w as AuthError, wr as empty, ws as logInfo, wt as Collector, xd as some$1, xf as isNone, xt as isStreamSchema, yc as uninterruptibleMask, yd as reduce, yn as TrueLiterals, ys as isEffect, yu as isFailure, z as errorReported, za as offerAll, zo as catchCause, zt as HttpClientErrorSchema } from "./contracts-PzeJtyhG.mjs";
 //#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/workers/WorkerError.js
 /**
 * Worker error reason for failures while spawning or setting up a worker.
@@ -7690,11 +7690,11 @@ const runWith = (command, config) => {
 };
 //#endregion
 //#region package.json
-var version = "0.1.1092";
+var version = "0.1.1095";
 //#endregion
 //#region src/main.cli.ts
 const server = pipe(String$1("server"), withDescription$1("Stash server; defaults to STASH_SERVER, then https://stash.mp281x.xyz"), withFallbackConfig(String$7("STASH_SERVER")), withDefault("https://stash.mp281x.xyz"));
-const keyFolder = map$2(String$7("HOME"), (home) => `${home}/.config/stash`);
+const keyFolder = map$2(String$7("HOME"), (home) => `${home}/.deslop/stash`);
 function section(title, text) {
 	return pipe(fromUndefinedOr(text), filter(isNonEmpty), map$3((found) => `## ${title}\n\n${found}`));
 }
@@ -7704,7 +7704,7 @@ const login = pipe(make("login", { key: pipe(Redacted("api-key"), withDescriptio
 	yield* fs.makeDirectory(folder, { recursive: true });
 	yield* fs.writeFileString(`${folder}/api-key`, value(input.key), { mode: 384 });
 	yield* logInfo(`Signed in; the API key is in ${folder}/api-key`);
-})), withDescription(`Keep an API key created at ${AUTH_URL} in ~/.config/stash/api-key for save.`), withExamples([{
+})), withDescription(`Keep an API key created at ${AUTH_URL} in ~/.deslop/stash/api-key for save.`), withExamples([{
 	command: "vpx @deslop/stash@latest login '<api key>'",
 	description: `Sign in with a key from ${AUTH_URL}.`
 }]));

package/dist/{contracts-nyOWldn4.mjs → contracts-PzeJtyhG.mjs}

@@ -11397,6 +11397,8 @@ const sleep$1 = (duration) => clockWith$1((clock) => clock.sleep(fromInputUnsafe
 /** @internal */
 const currentTimeMillis$1 = /*#__PURE__*/ clockWith$1((clock) => clock.currentTimeMillis);
 /** @internal */
+const currentTimeNanos$1 = /*#__PURE__*/ clockWith$1((clock) => clock.currentTimeNanos);
+/** @internal */
 const TimeoutErrorTypeId = "~effect/Cause/TimeoutError";
 /** @internal */
 const isTimeoutError$1 = (u) => hasProperty(u, TimeoutErrorTypeId);
@@ -14623,6 +14625,46 @@ const Clock = ClockRef;
 * @since 2.0.0
 */
 const currentTimeMillis = currentTimeMillis$1;
+/**
+* Returns an Effect that succeeds with the current Unix time in nanoseconds.
+*
+* **When to use**
+*
+* Use to create wall-clock timestamps from the active `Clock` service with
+* nanosecond precision.
+*
+* **Gotchas**
+*
+* The value can move backward or forward when the system wall clock is
+* corrected, so it is not suitable for measuring elapsed time.
+* The live clock allows up to one second of drift from `Date.now()` before
+* re-anchoring.
+*
+* **Example** (Reading nanoseconds)
+*
+* ```ts import.meta.vitest
+* import { Clock, Effect } from "effect"
+*
+* const testClock: Clock.Clock = {
+*   currentTimeMillisUnsafe: () => 1_000,
+*   currentTimeMillis: Effect.succeed(1_000),
+*   monotonicTimeNanosUnsafe: () => 1_000_000_000n,
+*   monotonicTimeNanos: Effect.succeed(1_000_000_000n),
+*   currentTimeNanosUnsafe: () => 1_000_000_000n,
+*   currentTimeNanos: Effect.succeed(1_000_000_000n),
+*   sleep: () => Effect.void
+* }
+*
+* await Effect.runPromise(Effect.provideService(Clock.currentTimeNanos, Clock.Clock, testClock)) // => 1_000_000_000n
+* ```
+*
+* @see {@link monotonicTimeNanos} for measuring elapsed time
+*
+* @stability stable
+* @category accessors
+* @since 2.0.0
+*/
+const currentTimeNanos = currentTimeNanos$1;
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/internal/dateTime.js
 /** @internal */
@@ -51076,12 +51118,13 @@ var AuthError = class extends TaggedError()("AuthError", {
 	cause: optional(Defect()),
 	message: String$2
 }) {};
+const User = Struct({
+	id: NonEmptyString,
+	name: NonEmptyString
+});
 const Session = pipe(StringFromBase64Url, decodeTo(fromJsonString(Struct({
 	expiresAt: Finite,
-	user: Struct({
-		id: NonEmptyString,
-		name: NonEmptyString
-	})
+	user: User
 }))));
 const Verification = Struct({
 	key: NonEmptyString,
@@ -51106,12 +51149,18 @@ const GitHubUser = Struct({
 //#endregion
 //#region ../../packages/auth/src/lib/utils.ts
 const AUTH_URL = "https://auth.mp281x.xyz";
+const development = pipe(String$1("NODE_ENV"), withDefault("production"), map((mode) => mode === "development"), mapError$2((cause) => AuthError.make({
+	cause,
+	message: "Cannot read the authentication mode"
+})));
 var CurrentUser = class extends Service$1()("@deslop/auth/lib/utils/CurrentUser") {};
 var RpcAuth = class RpcAuth extends Service()("@deslop/auth/lib/utils/RpcAuth", { error: AuthError }) {
-	static layerClient = (token) => layerClient(RpcAuth, (options) => flatMap$2(token, (value) => options.next({
-		...options.request,
-		headers: set$2(options.request.headers, "authorization", `Bearer ${value}`)
-	})));
+	static layerClient = (token) => layerClient(RpcAuth, (options) => gen(function* () {
+		return yield* options.next({
+			...options.request,
+			headers: set$2(options.request.headers, "authorization", `Bearer ${yield* token}`)
+		});
+	}));
 };
 //#endregion
 //#region src/services/notes/schema.ts
@@ -51320,4 +51369,4 @@ var RpcContracts = class extends make$7(make$9("notes.watch", {
 	payload: Struct({ id: NoteId })
 })).middleware(RpcAuth) {};
 //#endregion
-export { succeed as $, interruptAs as $a, replaceAll as $c, get$6 as $d, isNotNullish as $f, mapError as $i, make$35 as $l, toJsonSchemaDocument as $n, failCause$3 as $o, Objects as $r, scope as $s, FalseLiterals as $t, fromIterable$6 as $u, SignInParams as A, makeUnsafe$1 as Aa, zipWith as Ac, failVoid as Ad, String$6 as Af, decodeText$1 as Ai, squash as Al, decodeUnknownOption as An, annotateCurrentSpan as Ao, setAll$1 as Ar, matchCauseEffectEager as As, fromWebSocket as At, Tracer as Au, Terminal as B, shutdownUnsafe as Ba, catchDone as Bc, format$1 as Bd, getStackTraceLimit as Bf, fromChannel as Bi, provide$2 as Bl, isMinLength as Bn, catchFilter$2 as Bo, setUnsafe as Br, promise as Bs, TransportError as Bt, contains as Bu, AuthError as C, fromPull$1 as Ca, whileLoop as Cc, keys$1 as Cd, match$6 as Cf, defaultFormatter as Ci, hasInterrupts as Cl, UndefinedOr as Cn, isLoopback as Co, fromInput$1 as Cr, logWarning as Cs, makeCollectorUnsafe as Ct, forkUnsafe$1 as Cu, OAuthTokenError as D, mkUint8Array$1 as Da, withParentSpan as Dc, headUnsafe as Dd, some$1 as Df, catchTags as Di, isTimeoutError as Dl, decodeSync as Dn, acquireRelease as Do, merge as Dr, mapError$2 as Ds, SocketErrorReason as Dt, sync$2 as Du, OAuthFlow as E, mapError$1 as Ea, withLogSpan as Ec, empty$8 as Ed, orElseSome as Ef, catchReason as Ei, isNoSuchElementError as El, decodeEffect as En, unixPathAddress as Eo, isRedactedName$1 as Er, mapEager as Es, SocketError as Et, reportCauseUnsafe as Eu, runMain as F, make$27 as Fa, isSchedule as Fc, isSuccess$1 as Fd, PipeInspectableProto as Ff, failCause as Fi, effectContext as Fl, fromJsonString as Fn, cached as Fo, empty$4 as Fr, onExitPrimitive as Fs, EncodeError as Ft, Error$2 as Fu, Port as G, make$30 as Ga, includes as Gc, parts as Gd, toJson as Gf, fromReadableStream as Gi, unwrap$5 as Gl, makeFilter as Gn, catch_$2 as Go, toUint8Array as Gr, raceFirst as Gs, BooleanLiterals as Gt, ensure as Gu, layer$8 as H, takeAll as Ha, Random as Hc, max$1 as Hd, BaseProto as Hf, fromIterable$5 as Hi, succeed$5 as Hl, isSchema as Hn, catchReason$2 as Ho, fromReadable as Hr, provideContext$2 as Hs, Any as Ht, dedupeAdjacentWith as Hu, errorExitCode as I, offer as Ia, min as Ic, match$4 as Id, contA as If, filter as Ii, effectDiscard as Il, is as In, callback$1 as Io, expireCookieUnsafe as Ir, onInterrupt as Is, HttpClientError as It, TaggedClass as Iu, String$1 as J, await_ as Ja, length as Jc, zero$2 as Jd, equals$1 as Jf, map$1 as Ji, addFinalizerExit as Jl, optionalKey as Jn, delay as Jo, ChildProcessSpawner as Jr, retry as Js, DateTimeUtcFromString as Jt, filterMap as Ju, Record as K, set$3 as Ka, isEmpty$1 as Kc, seconds as Kd, format$2 as Kf, groupedWithin as Ki, Scope as Kl, mutable as Kn, context as Ko, fromWritable as Kr, repeat as Ks, Class as Kt, every$1 as Ku, errorReported as L, offerAll as La, passthrough$2 as Lc, succeed$8 as Ld, contE as Lf, flatMap as Li, launch as Ll, isGreaterThanOrEqualTo as Ln, catchCause$1 as Lo, fromSetCookie as Lr, option$1 as Ls, HttpClientErrorSchema as Lt, TaggedError$1 as Lu, LogToStderr as M, collect as Ma, exponential as Mc, getSuccess as Md, flip$1 as Mf, empty$5 as Mi, buildWithMemoMap as Ml, encodeSync as Mn, as as Mo, make$16 as Mr, never$1 as Ms, layerWebSocketConstructorGlobal as Mt, make$36 as Mu, layer as N, end as Na, forever$1 as Nc, isFailure$1 as Nd, mapInput as Nf, ensuring as Ni, buildWithScope as Nl, encodeTo as Nn, asSome as No, value as Nr, onError as Ns, DecodeError as Nt, nativeTracer as Nu, OAuthTokenResponse as O, pipeTo as Oa, withSpan as Oc, make$37 as Od, toArray as Of, catch_ as Oi, makeDieReason as Ol, decodeTo as On, all$1 as Oo, remove$1 as Or, match as Os, SocketOpenError as Ot, DisablePropagation as Ou, make as P, failCause$2 as Pa, fromStep as Pc, isResult as Pd, Prototype as Pf, fail$1 as Pi, effect as Pl, encodeUnknownEffect as Pn, asVoid as Po, stringOrRedacted as Pr, onExit$1 as Ps, EmptyBodyError as Pt, random as Pu, schema as Q, interruptAllAs as Qa, replace as Qc, empty$9 as Qd, isNotNull as Qf, mapEffect as Qi, forkUnsafe as Ql, toEncoded as Qn, fail$3 as Qo, Literal$1 as Qr, runSync$1 as Qs, Exit as Qt, flatMap$5 as Qu, layer$1 as R, offerUnsafe as Ra, spaced as Rc, try_$2 as Rd, withFiber$1 as Rf, flattenIterable as Ri, merge$3 as Rl, isInt as Rn, catchCauseIf as Ro, isEmpty as Rr, orDie$2 as Rs, InvalidUrlError as Rt, taggedEnum as Ru, RpcAuth as S, last as Sa, when as Sc, has$3 as Sd, map$9 as Sf, toEpochMillis as Si, hasDies as Sl, Uint8ArrayFromBase64 as Sn, isLinkLocal as So, empty$3 as Sr, logInfo as Ss, Collector as St, fiberEnterUninterruptibleUnsafe as Su, GitHubUser as T, map$2 as Ta, withFiberSucceed as Tc, toEntries as Td, orElse as Tf, FileSystem as Ti, interruptors as Tl, Unknown as Tn, isUnicast as To, get$2 as Tr, map$3 as Ts, Socket as Tt, onExitUnsafe as Tu, Crypto as U, publishUnsafe as Ua, camelToSnake as Uc, millis as Ud, Class$2 as Uf, fromPubSub as Ui, succeedContext as Ul, isSchemaError as Un, catchTag as Uo, pipeThroughDuplex as Ur, provideService$2 as Us, ArraySchema as Ut, drop as Uu, isQuitError as V, take$1 as Va, isDoneCause as Vc, fromInputUnsafe$1 as Vd, setStackTraceLimit as Vf, fromEffect as Vi, provideMerge as Vl, isPattern as Vn, catchIf as Vo, toSetCookieHeaders as Vr, provide as Vs, isHttpClientError as Vt, dedupe as Vu, Array$1 as W, unbounded as Wa, endsWith as Wc, minutes as Wd, NodeInspectSymbol as Wf, fromQueue as Wi, sync$1 as Wl, make$11 as Wn, catchTags$1 as Wo, toArrayBuffer as Wr, provideServiceEffect as Ws, Boolean$1 as Wt, empty$7 as Wu, all as X, interrupt as Xa, padStart as Xc, Service$1 as Xd, hasProperty as Xf, mapArray as Xi, closeUnsafe as Xl, toCodecJson as Xn, ensuring$2 as Xo, Filter as Xr, runFork as Xs, Duration as Xt, findFirstIndex as Xu, URL$1 as Y, getCurrent as Ya, match$1 as Yc, Reference as Yd, hash as Yf, mapAccum as Yi, close as Yl, tag as Yn, die$2 as Yo, Arrays as Yr, retryOrElse as Ys, Defect as Yt, findFirst as Yu, option as Z, interruptAll as Za, repeat$2 as Zc, add as Zd, isIterable as Zf, mapArrayEffect as Zi, fork as Zl, toCodecStringTree as Zn, exit as Zo, FilterGroup as Zr, runForkWith as Zs, Error$1 as Zt, findLast as Zu, Organization as _, tap as _a, uninterruptibleMask as _c, reverse as _d, getOrUndefined$1 as _f, decode as _i, done as _l, TrueLiterals as _n, inetAddressFromIpString as _o, empty$1 as _r, isEffect as _s, ClientAbort as _t, isSuccess as _u, FxConversation as a, pipeThroughChannel as aa, suspend$2 as ac, headNonEmpty as ad, merge$4 as af, isOptional as ai, trimEnd as al, MutableJson as an, mebibytes as ao, compose$1 as ap, omit as ar, forEach$1 as as, RpcSerialization as at, TracerTimingEnabled as au, AUTH_URL as b, toReadableStreamWith as ba, useSpan as bc, take$3 as bd, liftPredicate as bf, formatIso as bi, findError as bl, URLFromString as bn, ipv4ToOctets as bo, set as br, logError as bs, spanAttributes as bt, effectIsExit as bu, GitHubIssue as c, runCollect as ca, tapCause as cc, isReadonlyArrayNonEmpty as cd, exists as cf, optionalKey$1 as ci, round as cl, Null as cn, DnsError as co, constUndefined as cp, CurrentRedactedNames as cr, forkIn as cs, layerSchemaBinary as ct, into as cu, ImageType as d, runHead as da, timeoutOption as dc, lastNonEmpty as dd, flatMapNullishOr as df, resolveIdentifier as di, Done as dl, Record$1 as dn, nameServerFromInput as do, dual as dp, redactUrl as dr, fromResult as ds, constEof as dt, die$4 as du, mergeAll as ea, scoped as ec, get$5 as ed, getOrUndefined as ef, PropertySignature as ei, slice as el, Finite as en, runIn as eo, isNotUndefined as ep, toType as er, filterOrFail as es, unwrap as et, makeUnsafe$4 as eu, Note as f, runLast as fa, timeoutOrElse as fc, map$6 as fd, flatten$5 as ff, string as fi, IllegalArgumentError as fl, Redacted$1 as fn, domainNameFromStringUnsafe as fo, flow as fp, setAll as fr, gen as fs, constPing as ft, fail$5 as fu, OEmbed as g, takeUntil as ga, uninterruptible as gc, reduce as gd, getOrNull as gf, transformOptional as gi, die$3 as gl, TaggedError as gn, formatUrlUnsafe as go, has as gr, interruptible as gs, isWrapper as gt, isFailure as gu, NotesError as h, suspend as ha, try_ as hc, prepend$1 as hd, getOrElse as hf, transform as hi, combine as hl, Struct as hn, formatIp as ho, pipeArguments as hp, fromIterable as hr, interrupt$1 as hs, exitSchema as ht, isExit as hu, FileType as i, orDie as ia, succeedNone as ic, head as id, makeUnsafe$6 as if, isNever as ii, trim as il, Literals as in, gibibytes as io, or as ip, isSchemaError$1 as ir, fnUntraced as is, withRunClient as it, MinimumLogLevel as iu, Verification as j, bounded as ja, addDelay as jc, fromOption$2 as jd, combine$1 as jf, die as ji, CurrentMemoMap as jl, encodeEffect as jn, annotateLogs as jo, isRedacted as jr, matchEffect as js, layerWebSocket as jt, externalSpan as ju, Session as k, make$26 as ka, withTracerEnabled as kc, fail$7 as kd, Number$5 as kf, concat as ki, prettyErrors as kl, decodeUnknownEffect as kn, andThen as ko, set$2 as kr, matchCauseEffect as ks, SocketReadError as kt, ParentSpan as ku, GitHubReadme as l, runForEach as la, tapError as lc, join$1 as ld, filter$3 as lf, replaceChecks as li, Clock as ll, NullOr as ln, make$33 as lo, constVoid as lp, empty as lr, forkScoped as ls, RequestId as lt, isDeferred as lu, NoteJson as m, succeed$2 as ma, tryPromise as mc, of as md, fromUndefinedOr as mf, passthrough as mi, annotate$1 as ml, StringFromUriComponent as mn, formatInet as mo, pipe as mp, unwrap$1 as mr, ignoreCause as ms, ServerClient as mt, interrupt$2 as mu, Capture as n, mkUint8Array as na, sleep as nc, getUnsafe as nd, getUnsafe$1 as nf, Union$1 as ni, startsWith as nl, Json as nn, fromInput$2 as no, isTagged as np, withDecodingDefault as nr, flatMapEager as ns, Stdio as nt, CurrentLogAnnotations as nu, FxStatus as o, provideService as oa, sync as oc, isArrayNonEmpty as od, all$4 as of, mapOrSame as oi, max as ol, Never as on, zero$1 as oo, constFalse$1 as op, getReferenceKey as or, forever as os, json as ot, _await as ou, NoteId as p, scan as pa, transposeOption as pc, match$3 as pd, fromNullishOr as pf, toEncoded$1 as pi, StackTrace as pl, String$2 as pn, NetAddressError as po, identity as pp, toString as pr, ignore as ps, constPong as pt, failCause$5 as pu, Redacted as q, makeUnsafe$2 as qa, isNonEmpty$1 as qc, toMillis as qd, redact$2 as qf, limitBytes as qi, addFinalizer$1 as ql, optional as qn, contextWith as qo, make$18 as qr, result as qs, DateTimeUtc as qt, filter$2 as qu, Extraction as r, onEnd as ra, succeed$4 as rc, groupBy as rd, make$39 as rf, decodeTo$1 as ri, toLowerCase as rl, Literal as rn, fromInputUnsafe as ro, isUndefined as rp, withDecodingDefaultKey as rr, fn as rs, withRun as rt, CurrentLogSpans as ru, GitHubComment as s, run$1 as sa, tap$1 as sc, isReadonlyArrayEmpty as sd, contains$1 as sf, null_ as si, parse as sl, NonEmptyArray as sn, Dns as so, constTrue as sp, encodeUnknownEffect$1 as sr, forkChild as ss, layerJson as st, doneUnsafe as su, RpcContracts as t, mkString as ta, serviceOption as tc, getSomes as td, getOrUndefinedUnsafe as tf, Suspend as ti, split$1 as tl, Int as tn, badArgument as to, isObject as tp, withConstructorDefault as tr, flatMap$2 as ts, withDefault as tt, provide$3 as tu, GitHubRepo as u, runForEachArray as ua, timeout as uc, last$1 as ud, flatMap$7 as uf, resolveDescription as ui, currentTimeMillis as ul, Number$1 as un, makeRecordUnsafe as uo, constant as up, fromInput as ur, fromOption as us, ResponseDefectEncoded as ut, makeUnsafe$5 as uu, Reader as v, toReadableStream as va, updateContext as vc, some as vd, isNone as vf, encode as vi, fail$4 as vl, Tuple as vn, ipFromString as vo, fromIterable$2 as vr, log as vs, getStreamSchemas as vt, succeed$6 as vu, CallbackParams as w, fromTransform$1 as wa, withFiber as wc, map$7 as wd, none as wf, Path$1 as wi, hasInterruptsOnly as wl, Union as wn, isPrivate as wo, fromRecordUnsafe as wr, makeSpanScoped as ws, CloseEvent as wt, makeSpanUnsafe as wu, CurrentUser as x, unwrap$2 as xa, void_$1 as xc, takeRight as xd, liftThrowable as xf, now as xi, fromReasons as xl, Uint8Array$1 as xn, isInetAddressV6 as xo, CurrentRedactedNames$1 as xr, logFatal as xs, spanName as xt, fiberEnterInterruptibleUnsafe as xu, TikTokPage as y, toReadableStreamEffect as ya, updateService as yc, sort as yd, isSome as yf, encode$1 as yi, filterInterruptors as yl, URL$2 as yn, ipFromStringUnsafe as yo, get as yr, logDebug as ys, isStreamSchema as yt, ConsoleRef as yu, QuitError as z, shutdown as za, toStep as zc, days as zd, assignProperty as zf, fromArray as zi, mergeAll$2 as zl, isMaxLength as zn, catchDefect as zo, parseHeader as zr, orElseSucceed as zs, StatusCodeError as zt, appendAll$1 as zu };
+export { option as $, interruptAll as $a, repeat$2 as $c, Service$1 as $d, hasProperty as $f, mapArrayEffect as $i, closeUnsafe as $l, toCodecStringTree as $n, exit as $o, FilterGroup as $r, runForkWith as $s, Error$1 as $t, findFirstIndex as $u, Session as A, pipeTo as Aa, withSpan as Ac, headUnsafe as Ad, some$1 as Af, catch_ as Ai, isTimeoutError as Al, decodeTo as An, all$1 as Ao, remove$1 as Ar, match as As, SocketOpenError as At, sync$2 as Au, layer$1 as B, offerUnsafe as Ba, spaced as Bc, succeed$8 as Bd, contE as Bf, flattenIterable as Bi, launch as Bl, isInt as Bn, catchCauseIf as Bo, isEmpty as Br, orDie$2 as Bs, InvalidUrlError as Bt, TaggedError$1 as Bu, development as C, unwrap$2 as Ca, void_$1 as Cc, take$3 as Cd, liftPredicate as Cf, now as Ci, findError as Cl, Uint8Array$1 as Cn, isInetAddressV6 as Co, CurrentRedactedNames$1 as Cr, logFatal as Cs, spanName as Ct, effectIsExit as Cu, OAuthFlow as D, map$2 as Da, withFiberSucceed as Dc, map$7 as Dd, none as Df, FileSystem as Di, hasInterruptsOnly as Dl, Unknown as Dn, isUnicast as Do, get$2 as Dr, map$3 as Ds, Socket as Dt, makeSpanUnsafe as Du, GitHubUser as E, fromTransform$1 as Ea, withFiber as Ec, keys$1 as Ed, match$6 as Ef, Path$1 as Ei, hasInterrupts as El, Union as En, isPrivate as Eo, fromRecordUnsafe as Er, makeSpanScoped as Es, CloseEvent as Et, forkUnsafe$1 as Eu, layer as F, end as Fa, forever$1 as Fc, getSuccess as Fd, flip$1 as Ff, ensuring as Fi, buildWithMemoMap as Fl, encodeTo as Fn, asSome as Fo, value as Fr, onError as Fs, DecodeError as Ft, make$36 as Fu, Crypto as G, publishUnsafe as Ga, camelToSnake as Gc, max$1 as Gd, BaseProto as Gf, fromPubSub as Gi, succeed$5 as Gl, isSchemaError as Gn, catchTag as Go, pipeThroughDuplex as Gr, provideService$2 as Gs, ArraySchema as Gt, dedupeAdjacentWith as Gu, Terminal as H, shutdownUnsafe as Ha, catchDone as Hc, days as Hd, assignProperty as Hf, fromChannel as Hi, mergeAll$2 as Hl, isMinLength as Hn, catchFilter$2 as Ho, setUnsafe as Hr, promise as Hs, TransportError as Ht, appendAll$1 as Hu, make as I, failCause$2 as Ia, fromStep as Ic, isFailure$1 as Id, mapInput as If, fail$1 as Ii, buildWithScope as Il, encodeUnknownEffect as In, asVoid as Io, stringOrRedacted as Ir, onExit$1 as Is, EmptyBodyError as It, nativeTracer as Iu, Record as J, set$3 as Ja, isEmpty$1 as Jc, parts as Jd, toJson as Jf, groupedWithin as Ji, unwrap$5 as Jl, mutable as Jn, context as Jo, fromWritable as Jr, repeat as Js, Class as Jt, ensure as Ju, Array$1 as K, unbounded as Ka, endsWith as Kc, millis as Kd, Class$2 as Kf, fromQueue as Ki, succeedContext as Kl, make$11 as Kn, catchTags$1 as Ko, toArrayBuffer as Kr, provideServiceEffect as Ks, Boolean$1 as Kt, drop as Ku, runMain as L, make$27 as La, isSchedule as Lc, isResult as Ld, Prototype as Lf, failCause as Li, effect as Ll, fromJsonString as Ln, cached as Lo, empty$4 as Lr, onExitPrimitive as Ls, EncodeError as Lt, random as Lu, User as M, makeUnsafe$1 as Ma, zipWith as Mc, fail$7 as Md, Number$5 as Mf, decodeText$1 as Mi, prettyErrors as Ml, decodeUnknownOption as Mn, annotateCurrentSpan as Mo, setAll$1 as Mr, matchCauseEffectEager as Ms, fromWebSocket as Mt, ParentSpan as Mu, Verification as N, bounded as Na, addDelay as Nc, failVoid as Nd, String$6 as Nf, die as Ni, squash as Nl, encodeEffect as Nn, annotateLogs as No, isRedacted as Nr, matchEffect as Ns, layerWebSocket as Nt, Tracer as Nu, OAuthTokenError as O, mapError$1 as Oa, withLogSpan as Oc, toEntries as Od, orElse as Of, catchReason as Oi, interruptors as Ol, decodeEffect as On, unixPathAddress as Oo, isRedactedName$1 as Or, mapEager as Os, SocketError as Ot, onExitUnsafe as Ou, LogToStderr as P, collect as Pa, exponential as Pc, fromOption$2 as Pd, combine$1 as Pf, empty$5 as Pi, CurrentMemoMap as Pl, encodeSync as Pn, as as Po, make$16 as Pr, never$1 as Ps, layerWebSocketConstructorGlobal as Pt, externalSpan as Pu, all as Q, interrupt as Qa, padStart as Qc, Reference as Qd, hash as Qf, mapArray as Qi, close as Ql, toCodecJson as Qn, ensuring$2 as Qo, Filter as Qr, runFork as Qs, Duration as Qt, findFirst as Qu, errorExitCode as R, offer as Ra, min as Rc, isSuccess$1 as Rd, PipeInspectableProto as Rf, filter as Ri, effectContext as Rl, is as Rn, callback$1 as Ro, expireCookieUnsafe as Rr, onInterrupt as Rs, HttpClientError as Rt, Error$2 as Ru, RpcAuth as S, toReadableStreamWith as Sa, useSpan as Sc, sort as Sd, isSome as Sf, formatIso as Si, filterInterruptors as Sl, URLFromString as Sn, ipv4ToOctets as So, set as Sr, logError as Ss, spanAttributes as St, ConsoleRef as Su, CallbackParams as T, fromPull$1 as Ta, whileLoop as Tc, has$3 as Td, map$9 as Tf, defaultFormatter as Ti, hasDies as Tl, UndefinedOr as Tn, isLoopback as To, fromInput$1 as Tr, logWarning as Ts, makeCollectorUnsafe as Tt, fiberEnterUninterruptibleUnsafe as Tu, isQuitError as U, take$1 as Ua, isDoneCause as Uc, format$1 as Ud, getStackTraceLimit as Uf, fromEffect as Ui, provide$2 as Ul, isPattern as Un, catchIf as Uo, toSetCookieHeaders as Ur, provide as Us, isHttpClientError as Ut, contains as Uu, QuitError as V, shutdown as Va, toStep as Vc, try_$2 as Vd, withFiber$1 as Vf, fromArray as Vi, merge$3 as Vl, isMaxLength as Vn, catchDefect as Vo, parseHeader as Vr, orElseSucceed as Vs, StatusCodeError as Vt, taggedEnum as Vu, layer$8 as W, takeAll as Wa, Random as Wc, fromInputUnsafe$1 as Wd, setStackTraceLimit as Wf, fromIterable$5 as Wi, provideMerge as Wl, isSchema as Wn, catchReason$2 as Wo, fromReadable as Wr, provideContext$2 as Ws, Any as Wt, dedupe as Wu, String$1 as X, await_ as Xa, length as Xc, toMillis as Xd, redact$2 as Xf, map$1 as Xi, addFinalizer$1 as Xl, optionalKey as Xn, delay as Xo, ChildProcessSpawner as Xr, retry as Xs, DateTimeUtcFromString as Xt, filter$2 as Xu, Redacted as Y, makeUnsafe$2 as Ya, isNonEmpty$1 as Yc, seconds as Yd, format$2 as Yf, limitBytes as Yi, Scope as Yl, optional as Yn, contextWith as Yo, make$18 as Yr, result as Ys, DateTimeUtc as Yt, every$1 as Yu, URL$1 as Z, getCurrent as Za, match$1 as Zc, zero$2 as Zd, equals$1 as Zf, mapAccum as Zi, addFinalizerExit as Zl, tag as Zn, die$2 as Zo, Arrays as Zr, retryOrElse as Zs, Defect as Zt, filterMap as Zu, Organization as _, suspend as _a, try_ as _c, of as _d, fromUndefinedOr as _f, transform as _i, annotate$1 as _l, Struct as _n, formatIp as _o, pipe as _p, fromIterable as _r, interrupt$1 as _s, exitSchema as _t, interrupt$2 as _u, FxConversation as a, onEnd as aa, succeed$4 as ac, getUnsafe as ad, getUnsafe$1 as af, decodeTo$1 as ai, toLowerCase as al, Literal as an, fromInputUnsafe as ao, isTagged as ap, withDecodingDefaultKey as ar, fn as as, withRun as at, CurrentLogAnnotations as au, AUTH_URL as b, toReadableStream as ba, updateContext as bc, reverse as bd, getOrUndefined$1 as bf, encode as bi, done as bl, Tuple as bn, ipFromString as bo, fromIterable$2 as br, log as bs, getStreamSchemas as bt, isSuccess as bu, GitHubIssue as c, provideService as ca, sync as cc, headNonEmpty as cd, merge$4 as cf, mapOrSame as ci, max as cl, Never as cn, zero$1 as co, compose$1 as cp, getReferenceKey as cr, forever as cs, json as ct, TracerTimingEnabled as cu, ImageType as d, runForEach as da, tapError as dc, isReadonlyArrayNonEmpty as dd, exists as df, replaceChecks as di, Clock as dl, NullOr as dn, make$33 as do, constUndefined as dp, empty as dr, forkScoped as ds, RequestId as dt, into as du, mapEffect as ea, runSync$1 as ec, findLast as ed, add as ef, Literal$1 as ei, replace as el, Exit as en, interruptAllAs as eo, isIterable as ep, toEncoded as er, fail$3 as es, schema as et, fork as eu, Note as f, runForEachArray as fa, timeout as fc, join$1 as fd, filter$3 as ff, resolveDescription as fi, currentTimeMillis as fl, Number$1 as fn, makeRecordUnsafe as fo, constVoid as fp, fromInput as fr, fromOption as fs, ResponseDefectEncoded as ft, isDeferred as fu, OEmbed as g, succeed$2 as ga, tryPromise as gc, match$3 as gd, fromNullishOr as gf, passthrough as gi, StackTrace as gl, StringFromUriComponent as gn, formatInet as go, identity as gp, unwrap$1 as gr, ignoreCause as gs, ServerClient as gt, failCause$5 as gu, NotesError as h, scan as ha, transposeOption as hc, map$6 as hd, flatten$5 as hf, toEncoded$1 as hi, IllegalArgumentError as hl, String$2 as hn, NetAddressError as ho, flow as hp, toString as hr, ignore as hs, constPong as ht, fail$5 as hu, FileType as i, mkUint8Array as ia, sleep as ic, getSomes as id, getOrUndefinedUnsafe as if, Union$1 as ii, startsWith as il, Json as in, fromInput$2 as io, isObject as ip, withDecodingDefault as ir, flatMapEager as is, Stdio as it, provide$3 as iu, SignInParams as j, make$26 as ja, withTracerEnabled as jc, make$37 as jd, toArray as jf, concat as ji, makeDieReason as jl, decodeUnknownEffect as jn, andThen as jo, set$2 as jr, matchCauseEffect as js, SocketReadError as jt, DisablePropagation as ju, OAuthTokenResponse as k, mkUint8Array$1 as ka, withParentSpan as kc, empty$8 as kd, orElseSome as kf, catchTags as ki, isNoSuchElementError as kl, decodeSync as kn, acquireRelease as ko, merge as kr, mapError$2 as ks, SocketErrorReason as kt, reportCauseUnsafe as ku, GitHubReadme as l, run$1 as la, tap$1 as lc, isArrayNonEmpty as ld, all$4 as lf, null_ as li, parse as ll, NonEmptyArray as ln, Dns as lo, constFalse$1 as lp, encodeUnknownEffect$1 as lr, forkChild as ls, layerJson as lt, _await as lu, NoteJson as m, runLast as ma, timeoutOrElse as mc, lastNonEmpty as md, flatMapNullishOr as mf, string as mi, Done as ml, Redacted$1 as mn, domainNameFromStringUnsafe as mo, dual as mp, setAll as mr, gen as ms, constPing as mt, die$4 as mu, Capture as n, mergeAll as na, scoped as nc, fromIterable$6 as nd, get$6 as nf, PropertySignature as ni, slice as nl, Finite as nn, runIn as no, isNotNullish as np, toType as nr, filterOrFail as ns, unwrap as nt, make$35 as nu, FxStatus as o, orDie as oa, succeedNone as oc, groupBy as od, make$39 as of, isNever as oi, trim as ol, Literals as on, gibibytes as oo, isUndefined as op, isSchemaError$1 as or, fnUntraced as os, withRunClient as ot, CurrentLogSpans as ou, NoteId as p, runHead as pa, timeoutOption as pc, last$1 as pd, flatMap$7 as pf, resolveIdentifier as pi, currentTimeNanos as pl, Record$1 as pn, nameServerFromInput as po, constant as pp, redactUrl as pr, fromResult as ps, constEof as pt, makeUnsafe$5 as pu, Port as q, make$30 as qa, includes as qc, minutes as qd, NodeInspectSymbol as qf, fromReadableStream as qi, sync$1 as ql, makeFilter as qn, catch_$2 as qo, toUint8Array as qr, raceFirst as qs, BooleanLiterals as qt, empty$7 as qu, Extraction as r, mkString as ra, serviceOption as rc, get$5 as rd, getOrUndefined as rf, Suspend as ri, split$1 as rl, Int as rn, badArgument as ro, isNotUndefined as rp, withConstructorDefault as rr, flatMap$2 as rs, withDefault as rt, makeUnsafe$4 as ru, GitHubComment as s, pipeThroughChannel as sa, suspend$2 as sc, head as sd, makeUnsafe$6 as sf, isOptional as si, trimEnd as sl, MutableJson as sn, mebibytes as so, or as sp, omit as sr, forEach$1 as ss, RpcSerialization as st, MinimumLogLevel as su, RpcContracts as t, mapError as ta, scope as tc, flatMap$5 as td, empty$9 as tf, Objects as ti, replaceAll as tl, FalseLiterals as tn, interruptAs as to, isNotNull as tp, toJsonSchemaDocument as tr, failCause$3 as ts, succeed as tt, forkUnsafe as tu, GitHubRepo as u, runCollect as ua, tapCause as uc, isReadonlyArrayEmpty as ud, contains$1 as uf, optionalKey$1 as ui, round as ul, Null as un, DnsError as uo, constTrue as up, CurrentRedactedNames as ur, forkIn as us, layerSchemaBinary as ut, doneUnsafe as uu, Reader as v, takeUntil as va, uninterruptible as vc, prepend$1 as vd, getOrElse as vf, transformOptional as vi, combine as vl, TaggedError as vn, formatUrlUnsafe as vo, pipeArguments as vp, has as vr, interruptible as vs, isWrapper as vt, isExit as vu, AuthError as w, last as wa, when as wc, takeRight as wd, liftThrowable as wf, toEpochMillis as wi, fromReasons as wl, Uint8ArrayFromBase64 as wn, isLinkLocal as wo, empty$3 as wr, logInfo as ws, Collector as wt, fiberEnterInterruptibleUnsafe as wu, CurrentUser as x, toReadableStreamEffect as xa, updateService as xc, some as xd, isNone as xf, encode$1 as xi, fail$4 as xl, URL$2 as xn, ipFromStringUnsafe as xo, get as xr, logDebug as xs, isStreamSchema as xt, succeed$6 as xu, TikTokPage as y, tap as ya, uninterruptibleMask as yc, reduce as yd, getOrNull as yf, decode as yi, die$3 as yl, TrueLiterals as yn, inetAddressFromIpString as yo, empty$1 as yr, isEffect as ys, ClientAbort as yt, isFailure as yu, errorReported as z, offerAll as za, passthrough$2 as zc, match$4 as zd, contA as zf, flatMap as zi, effectDiscard as zl, isGreaterThanOrEqualTo as zn, catchCause$1 as zo, fromSetCookie as zr, option$1 as zs, HttpClientErrorSchema as zt, TaggedClass as zu };

package/dist/server.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env -S node --max-old-space-size=16384 --heapsnapshot-near-heap-limit=3 --report-on-fatalerror
-import { $ as succeed$5, $a as interruptAs, $c as replaceAll, $d as get$6, $f as isNotNullish, $i as mapError$1, $l as make$38, $n as toJsonSchemaDocument, $o as failCause, $r as Objects, $s as scope, $u as fromIterable$1, A as SignInParams, Aa as makeUnsafe$8, Ac as zipWith, Ad as failVoid, Af as String$3, Ai as decodeText, Al as squash, An as decodeUnknownOption, Ao as annotateCurrentSpan, Ar as setAll, As as matchCauseEffectEager, At as fromWebSocket, Au as Tracer, Bc as catchDone, Bd as format$2, Bf as getStackTraceLimit, Bl as provide$1, Bn as isMinLength, Br as setUnsafe$2, Bs as promise, Bt as TransportError, Bu as contains$1, C as AuthError, Cc as whileLoop, Cd as keys, Cf as match$1, Ci as defaultFormatter, Cl as hasInterrupts, Cn as UndefinedOr, Co as isLoopback, Cr as fromInput$1, Cs as logWarning, Ct as makeCollectorUnsafe, Cu as forkUnsafe, D as OAuthTokenError, Dc as withParentSpan, Dd as headUnsafe, Df as some$1, Di as catchTags$1, Dl as isTimeoutError, Dn as decodeSync, Do as acquireRelease, Dr as merge$2, Ds as mapError, E as OAuthFlow, Ec as withLogSpan, Ed as empty$12, Ef as orElseSome, Ei as catchReason$1, El as isNoSuchElementError, En as decodeEffect, Eo as unixPathAddress, Er as isRedactedName, Es as mapEager, Et as SocketError, Eu as reportCauseUnsafe, F as runMain, Fa as make$39, Fc as isSchedule, Fd as isSuccess, Ff as PipeInspectableProto, Fi as failCause$3, Fl as effectContext, Fn as fromJsonString, Fo as cached, Fr as empty$9, Fs as onExitPrimitive, Ft as EncodeError, Fu as Error$1, G as Port, Ga as make$36, Gc as includes, Gd as parts, Gf as toJson, Gi as fromReadableStream, Gl as unwrap$3, Gn as makeFilter, Go as catch_, Gr as toUint8Array$1, Gs as raceFirst, Gu as ensure, H as layer$10, Ha as takeAll, Hc as Random$2, Hd as max$1, Hf as BaseProto, Hi as fromIterable, Hl as succeed$2, Hn as isSchema, Ho as catchReason, Hr as fromReadable, Hs as provideContext, Ht as Any, Hu as dedupeAdjacentWith, Ia as offer, Id as match$3, If as contA, Ii as filter$6, Il as effectDiscard, In as is$4, Io as callback, Ir as expireCookieUnsafe$1, Is as onInterrupt, It as HttpClientError, Iu as TaggedClass, J as String$2, Ja as await_, Jc as length, Jd as zero$1, Jf as equals, Ji as map$2, Jl as addFinalizerExit, Jn as optionalKey, Jr as ChildProcessSpawner, Js as retry, Jt as DateTimeUtcFromString, Ju as filterMap, K as Record, Ka as set$2, Kc as isEmpty$2, Kd as seconds, Kf as format$1, Ki as groupedWithin, Kl as Scope, Kn as mutable, Ko as context, Kr as fromWritable, Ks as repeat, Kt as Class$1, Ku as every, La as offerAll, Lc as passthrough, Ld as succeed, Lf as contE, Li as flatMap$3, Ll as launch, Ln as isGreaterThanOrEqualTo, Lo as catchCause, Lr as fromSetCookie, Ls as option$1, Lu as TaggedError, Ma as collect, Md as getSuccess, Mf as flip, Mi as empty$10, Ml as buildWithMemoMap, Mn as encodeSync, Mo as as$1, Mr as make$46, Ms as never, Mu as make$43, N as layer$12, Na as end$1, Nc as forever, Nd as isFailure, Nf as mapInput, Ni as ensuring, Nl as buildWithScope, Nn as encodeTo, No as asSome, Nr as value$2, Ns as onError, Nt as DecodeError, Nu as nativeTracer, O as OAuthTokenResponse, Oa as pipeTo, Oc as withSpan, Od as make$47, Of as toArray$1, Oi as catch_$1, Ol as makeDieReason, On as decodeTo, Oo as all$1, Or as remove$3, Ot as SocketOpenError, Ou as DisablePropagation, P as make$42, Pa as failCause$2, Pc as fromStep, Pd as isResult, Pf as Prototype, Pi as fail$2, Pl as effect, Pn as encodeUnknownEffect$1, Po as asVoid, Pr as stringOrRedacted, Ps as onExit, Pt as EmptyBodyError, Pu as random$1, Q as schema, Qa as interruptAllAs, Qc as replace$1, Qf as isNotNull, Qi as mapEffect, Ql as forkUnsafe$1, Qn as toEncoded$1, Qo as fail$1, Qr as Literal$2, Qs as runSync, Qt as Exit$1, Qu as flatMap$2, R as layer$11, Ra as offerUnsafe, Rc as spaced, Rd as try_$1, Ri as flattenIterable, Rl as merge$3, Rn as isInt, Rr as isEmpty$1, Rs as orDie, Rt as InvalidUrlError, S as RpcAuth, Sa as last$2, Sc as when$2, Sd as has$4, Sf as map$5, Si as toEpochMillis, Sl as hasDies, Sn as Uint8ArrayFromBase64, So as isLinkLocal, Sr as empty$8, Ss as logInfo, St as Collector, Su as fiberEnterUninterruptibleUnsafe, T as GitHubUser, Ta as map$4, Tc as withFiberSucceed, Td as toEntries, Tf as orElse$2, Ti as FileSystem, Tn as Unknown, To as isUnicast, Tr as get$7, Ts as map$1, Tu as onExitUnsafe, U as Crypto, Ua as publishUnsafe, Uc as camelToSnake, Ud as millis, Uf as Class, Ui as fromPubSub, Ul as succeedContext, Un as isSchemaError$1, Uo as catchTag, Ur as pipeThroughDuplex, Us as provideService, Ut as ArraySchema, Uu as drop, Va as take, Vd as fromInputUnsafe$1, Vf as setStackTraceLimit, Vi as fromEffect, Vl as provideMerge, Vn as isPattern, Vo as catchIf, Vr as toSetCookieHeaders, Vs as provide$3, Vt as isHttpClientError, Vu as dedupe, W as Array$1, Wa as unbounded, Wc as endsWith, Wd as minutes, Wf as NodeInspectSymbol, Wi as fromQueue, Wl as sync$1, Wn as make$45, Wo as catchTags, Wr as toArrayBuffer, Ws as provideServiceEffect, Wt as Boolean$2, Wu as empty$11, X as all, Xa as interrupt$2, Xc as padStart, Xd as Service, Xf as hasProperty, Xi as mapArray, Xl as closeUnsafe, Xn as toCodecJson, Xo as ensuring$1, Xr as Filter, Xs as runFork, Xt as Duration, Xu as findFirstIndex, Y as URL$1, Ya as getCurrent, Yc as match$2, Yd as Reference, Yf as hash, Yi as mapAccum, Yl as close, Yn as tag, Yo as die$2, Yr as Arrays, Yt as Defect, Yu as findFirst, Z as option, Za as interruptAll, Zc as repeat$1, Zd as add$1, Zf as isIterable, Zi as mapArrayEffect, Zl as fork, Zo as exit, Zr as FilterGroup, Zs as runForkWith, Zt as Error$2, _ as Organization, _a as tap$2, _c as uninterruptibleMask, _d as reverse, _f as getOrUndefined, _i as decode$3, _o as inetAddressFromIpString, _r as empty$13, _s as isEffect, _t as ClientAbort$1, _u as isSuccess$1, a as FxConversation, aa as pipeThroughChannel, ac as suspend, ad as headNonEmpty, af as merge$1, ai as isOptional, al as trimEnd, an as MutableJson, ao as mebibytes, ap as compose$1, ar as omit, as as forEach, at as RpcSerialization, au as TracerTimingEnabled, b as AUTH_URL, bc as useSpan, bd as take$1, bf as liftPredicate, bi as formatIso, bn as URLFromString, bo as ipv4ToOctets, br as set$4, bt as spanAttributes, bu as effectIsExit, c as GitHubIssue, ca as runCollect, cc as tapCause, cd as isReadonlyArrayNonEmpty, cf as exists, ci as optionalKey$1, cn as Null, co as DnsError, cp as constUndefined, cr as CurrentRedactedNames$1, cs as forkIn, ct as layerSchemaBinary, cu as into, d as ImageType, dc as timeoutOption, dd as lastNonEmpty, df as flatMapNullishOr, di as resolveIdentifier, dn as Record$1, do as nameServerFromInput, dp as dual, dr as redactUrl, ds as fromResult, dt as constEof, du as die, ea as mergeAll$1, ec as scoped, ed as get$8, ef as getOrUndefined$1, ei as PropertySignature, el as slice$2, en as Finite, eo as runIn, ep as isNotUndefined, er as toType, es as filterOrFail, et as unwrap$4, eu as makeUnsafe$4, f as Note, fa as runLast, fc as timeoutOrElse, fd as map$3, ff as flatten, fi as string, fl as IllegalArgumentError, fn as Redacted$1, fo as domainNameFromStringUnsafe, fp as flow, fr as setAll$1, fs as gen, fu as fail$3, g as OEmbed, ga as takeUntil, gc as uninterruptible, gd as reduce, gf as getOrNull, gi as transformOptional, gl as die$1, gn as TaggedError$1, go as formatUrlUnsafe, gr as has$3, gs as interruptible, gt as isWrapper, gu as isFailure$1, h as NotesError, ha as suspend$1, hc as try_, hd as prepend$2, hf as getOrElse, hi as transform$1, hl as combine, hn as Struct, ho as formatIp, hp as pipeArguments, hr as fromIterable$2, hs as interrupt, ht as exitSchema, hu as isExit, i as FileType, ia as orDie$1, ic as succeedNone, id as head, if as makeUnsafe$5, ii as isNever, il as trim, in as Literals, io as gibibytes, ip as or$1, ir as isSchemaError, is as fnUntraced, j as Verification, jc as addDelay, jd as fromOption$1, jf as combine$1, ji as die$3, jl as CurrentMemoMap, jn as encodeEffect, jo as annotateLogs, jr as isRedacted, js as matchEffect, ju as externalSpan, k as Session, ka as make$37, kc as withTracerEnabled, kd as fail, kf as Number$1, ki as concat, kl as prettyErrors, kn as decodeUnknownEffect, ko as andThen, kr as set$3, ks as matchCauseEffect, ku as ParentSpan, l as GitHubReadme, la as runForEach, lc as tapError$1, ld as join$1, lf as filter$4, li as replaceChecks, ll as Clock, ln as NullOr, lo as make$40, lp as constVoid, lr as empty$7, ls as forkScoped, lt as RequestId, lu as isDeferred, m as NoteJson, ma as succeed$3, mc as tryPromise, md as of, mf as fromUndefinedOr, mi as passthrough$1, ml as annotate, mn as StringFromUriComponent, mo as formatInet, mp as pipe, mr as unwrap$1, mt as ServerClient, mu as interrupt$1, n as Capture, na as mkUint8Array, nc as sleep, nd as getUnsafe$2, nf as getUnsafe$1, ni as Union$1, nl as startsWith, nn as Json, no as fromInput$2, np as isTagged, nr as withDecodingDefault, ns as flatMapEager, nu as CurrentLogAnnotations, o as FxStatus, oa as provideService$1, oc as sync, od as isArrayNonEmpty, of as all$2, oi as mapOrSame, ol as max$2, on as Never, oo as zero, op as constFalse, or as getReferenceKey, os as forever$1, ot as json$1, ou as _await, p as NoteId, pa as scan, pc as transposeOption, pf as fromNullishOr, pi as toEncoded, pl as StackTrace, pn as String$1, po as NetAddressError, pp as identity, pr as toString$2, ps as ignore$1, pt as constPong, pu as failCause$1, q as Redacted, qa as makeUnsafe$7, qc as isNonEmpty, qd as toMillis, qf as redact, qi as limitBytes, ql as addFinalizer, qn as optional$1, qo as contextWith, qr as make$44, qs as result$1, qt as DateTimeUtc, qu as filter$5, r as Extraction, ra as onEnd, rc as succeed$1, rd as groupBy, rf as make$41, ri as decodeTo$1, rl as toLowerCase, rn as Literal$1, ro as fromInputUnsafe, rp as isUndefined, rr as withDecodingDefaultKey, rs as fn$1, rt as withRun, ru as CurrentLogSpans, s as GitHubComment, sa as run$3, sc as tap$1, sd as isReadonlyArrayEmpty, sf as contains$2, si as null_, sl as parse$10, sn as NonEmptyArray, so as Dns, sp as constTrue, sr as encodeUnknownEffect, ss as forkChild, st as layerJson$1, su as doneUnsafe, t as RpcContracts, ta as mkString, tc as serviceOption, td as getSomes, tf as getOrUndefinedUnsafe, ti as Suspend, tl as split, tn as Int, to as badArgument, tp as isObject, tr as withConstructorDefault, ts as flatMap, tt as withDefault, tu as provide$2, u as GitHubRepo, ua as runForEachArray, uc as timeout, ud as last$1, uf as flatMap$1, ui as resolveDescription, ul as currentTimeMillis, un as Number$2, uo as makeRecordUnsafe, up as constant, ur as fromInput, us as fromOption, ut as ResponseDefectEncoded, uu as makeUnsafe$6, v as Reader, va as toReadableStream, vc as updateContext, vd as some$2, vf as isNone, vi as encode, vl as fail$4, vn as Tuple, vo as ipFromString, vr as fromIterable$3, vs as log, vt as getStreamSchemas, vu as succeed$4, w as CallbackParams, wa as fromTransform, wc as withFiber, wd as map$6, wf as none, wi as Path, wl as hasInterruptsOnly, wn as Union, wo as isPrivate, wr as fromRecordUnsafe, ws as makeSpanScoped, wt as CloseEvent, wu as makeSpanUnsafe, x as CurrentUser, xa as unwrap$2, xc as void_, xd as takeRight, xf as liftThrowable, xi as now, xl as fromReasons, xn as Uint8Array$2, xo as isInetAddressV6, xr as CurrentRedactedNames, xs as logFatal, xt as spanName, xu as fiberEnterInterruptibleUnsafe, y as TikTokPage, ya as toReadableStreamEffect, yc as updateService, yd as sort, yf as isSome, yi as encode$1, yl as filterInterruptors, yn as URL$2, yo as ipFromStringUnsafe, yr as get$9, ys as logDebug, yt as isStreamSchema, za as shutdown, zc as toStep, zd as days, zf as assignProperty, zi as fromArray, zl as mergeAll, zn as isMaxLength, zo as catchDefect, zr as parseHeader, zs as orElseSucceed, zt as StatusCodeError, zu as appendAll } from "./contracts-nyOWldn4.mjs";
+import { $ as option, $a as interruptAll, $c as repeat$1, $d as Service, $f as hasProperty, $i as mapArrayEffect, $l as closeUnsafe, $o as exit, $r as FilterGroup, $s as runForkWith, $t as Error$2, $u as findFirstIndex, A as Session, Aa as pipeTo, Ac as withSpan, Ad as headUnsafe, Af as some$1, Ai as catch_$1, Al as isTimeoutError, An as decodeTo, Ao as all$1, Ar as remove$3, At as SocketOpenError, B as layer$11, Ba as offerUnsafe, Bc as spaced, Bd as succeed, Bf as contE, Bi as flattenIterable, Bl as launch, Bn as isInt, Br as isEmpty$1, Bs as orDie, Bt as InvalidUrlError, Bu as TaggedError, C as development, Ca as unwrap$2, Cc as void_, Cd as take$1, Cf as liftPredicate, Ci as now, Cn as Uint8Array$2, Co as isInetAddressV6, Cr as CurrentRedactedNames, Cs as logFatal, Ct as spanName, Cu as effectIsExit, D as OAuthFlow, Da as map$4, Dc as withFiberSucceed, Dd as map$6, Df as none, Di as FileSystem, Dl as hasInterruptsOnly, Dn as Unknown, Do as isUnicast, Dr as get$7, Ds as map$1, Du as makeSpanUnsafe, E as GitHubUser, Ea as fromTransform, Ec as withFiber, Ed as keys, Ef as match$1, Ei as Path, El as hasInterrupts, En as Union, Eo as isPrivate, Er as fromRecordUnsafe, Es as makeSpanScoped, Et as CloseEvent, Eu as forkUnsafe, F as layer$12, Fa as end$1, Fc as forever, Fd as getSuccess, Ff as flip, Fi as ensuring, Fl as buildWithMemoMap, Fn as encodeTo, Fo as asSome, Fr as value$2, Fs as onError, Ft as DecodeError, Fu as make$43, G as Crypto, Ga as publishUnsafe, Gc as camelToSnake, Gd as max$1, Gf as BaseProto, Gi as fromPubSub, Gl as succeed$2, Gn as isSchemaError$1, Go as catchTag, Gr as pipeThroughDuplex, Gs as provideService, Gt as ArraySchema, Gu as dedupeAdjacentWith, Hc as catchDone, Hd as days, Hf as assignProperty, Hl as mergeAll, Hn as isMinLength, Hr as setUnsafe$2, Hs as promise, Ht as TransportError, Hu as appendAll, I as make$42, Ia as failCause$2, Ic as fromStep, Id as isFailure, If as mapInput, Ii as fail$2, Il as buildWithScope, In as encodeUnknownEffect$1, Io as asVoid, Ir as stringOrRedacted, Is as onExit, It as EmptyBodyError, Iu as nativeTracer, J as Record, Ja as set$2, Jc as isEmpty$2, Jd as parts, Jf as toJson, Ji as groupedWithin, Jl as unwrap$3, Jn as mutable, Jo as context, Jr as fromWritable, Js as repeat, Jt as Class$1, Ju as ensure, K as Array$1, Ka as unbounded, Kc as endsWith, Kd as millis, Kf as Class, Ki as fromQueue, Kl as succeedContext, Kn as make$45, Ko as catchTags, Kr as toArrayBuffer, Ks as provideServiceEffect, Kt as Boolean$2, Ku as drop, L as runMain, La as make$39, Lc as isSchedule, Ld as isResult, Lf as Prototype, Li as failCause$3, Ll as effect, Ln as fromJsonString, Lo as cached, Lr as empty$9, Ls as onExitPrimitive, Lt as EncodeError, Lu as random$1, M as User, Ma as makeUnsafe$8, Mc as zipWith, Md as fail, Mf as Number$1, Mi as decodeText, Ml as prettyErrors, Mn as decodeUnknownOption, Mo as annotateCurrentSpan, Mr as setAll, Ms as matchCauseEffectEager, Mt as fromWebSocket, Mu as ParentSpan, N as Verification, Nc as addDelay, Nd as failVoid, Nf as String$3, Ni as die$3, Nl as squash, Nn as encodeEffect, No as annotateLogs, Nr as isRedacted, Ns as matchEffect, Nu as Tracer, O as OAuthTokenError, Oc as withLogSpan, Od as toEntries, Of as orElse$2, Oi as catchReason$1, On as decodeEffect, Oo as unixPathAddress, Or as isRedactedName, Os as mapEager, Ot as SocketError, Ou as onExitUnsafe, Pa as collect, Pd as fromOption$1, Pf as combine$1, Pi as empty$10, Pl as CurrentMemoMap, Pn as encodeSync, Po as as$1, Pr as make$46, Ps as never, Pu as externalSpan, Q as all, Qa as interrupt$2, Qc as padStart, Qd as Reference, Qf as hash, Qi as mapArray, Ql as close, Qn as toCodecJson, Qo as ensuring$1, Qr as Filter, Qs as runFork, Qt as Duration, Qu as findFirst, Ra as offer, Rd as isSuccess, Rf as PipeInspectableProto, Ri as filter$6, Rl as effectContext, Rn as is$4, Ro as callback, Rr as expireCookieUnsafe$1, Rs as onInterrupt, Rt as HttpClientError, Ru as Error$1, S as RpcAuth, Sc as useSpan, Sd as sort, Sf as isSome, Si as formatIso, Sl as filterInterruptors, Sn as URLFromString, So as ipv4ToOctets, Sr as set$4, St as spanAttributes, T as CallbackParams, Tc as whileLoop, Td as has$4, Tf as map$5, Ti as defaultFormatter, Tl as hasDies, Tn as UndefinedOr, To as isLoopback, Tr as fromInput$1, Ts as logWarning, Tt as makeCollectorUnsafe, Tu as fiberEnterUninterruptibleUnsafe, Ua as take, Ud as format$2, Uf as getStackTraceLimit, Ui as fromEffect, Ul as provide$1, Un as isPattern, Uo as catchIf, Ur as toSetCookieHeaders, Us as provide$3, Ut as isHttpClientError, Uu as contains$1, Va as shutdown, Vc as toStep, Vd as try_$1, Vi as fromArray, Vl as merge$3, Vn as isMaxLength, Vo as catchDefect, Vr as parseHeader, Vs as orElseSucceed, Vt as StatusCodeError, W as layer$10, Wa as takeAll, Wc as Random$2, Wd as fromInputUnsafe$1, Wf as setStackTraceLimit, Wi as fromIterable, Wl as provideMerge, Wn as isSchema, Wo as catchReason, Wr as fromReadable, Ws as provideContext, Wt as Any, Wu as dedupe, X as String$2, Xa as await_, Xc as length, Xd as toMillis, Xf as redact, Xi as map$2, Xl as addFinalizer, Xn as optionalKey, Xr as ChildProcessSpawner, Xs as retry, Xt as DateTimeUtcFromString, Xu as filter$5, Y as Redacted, Ya as makeUnsafe$7, Yc as isNonEmpty, Yd as seconds, Yf as format$1, Yi as limitBytes, Yl as Scope, Yn as optional$1, Yo as contextWith, Yr as make$44, Ys as result$1, Yt as DateTimeUtc, Yu as every, Z as URL$1, Za as getCurrent, Zc as match$2, Zd as zero$1, Zf as equals, Zi as mapAccum, Zl as addFinalizerExit, Zn as tag, Zo as die$2, Zr as Arrays, Zt as Defect, Zu as filterMap, _ as Organization, _a as suspend$1, _c as try_, _d as of, _f as fromUndefinedOr, _i as transform$1, _l as annotate, _n as Struct, _o as formatIp, _p as pipe, _r as fromIterable$2, _s as interrupt, _t as exitSchema, _u as interrupt$1, a as FxConversation, aa as onEnd, ac as succeed$1, ad as getUnsafe$2, af as getUnsafe$1, ai as decodeTo$1, al as toLowerCase, an as Literal$1, ao as fromInputUnsafe, ap as isTagged, ar as withDecodingDefaultKey, as as fn$1, at as withRun, au as CurrentLogAnnotations, b as AUTH_URL, ba as toReadableStream, bc as updateContext, bd as reverse, bf as getOrUndefined, bi as encode, bn as Tuple, bo as ipFromString, br as fromIterable$3, bs as log, bt as getStreamSchemas, bu as isSuccess$1, c as GitHubIssue, ca as provideService$1, cc as sync, cd as headNonEmpty, cf as merge$1, ci as mapOrSame, cl as max$2, cn as Never, co as zero, cp as compose$1, cr as getReferenceKey, cs as forever$1, ct as json$1, cu as TracerTimingEnabled, d as ImageType, da as runForEach, dc as tapError$1, dd as isReadonlyArrayNonEmpty, df as exists, di as replaceChecks, dl as Clock, dn as NullOr, do as make$40, dp as constUndefined, dr as empty$7, ds as forkScoped, dt as RequestId, du as into, ea as mapEffect, ec as runSync, ef as add$1, ei as Literal$2, el as replace$1, en as Exit$1, eo as interruptAllAs, ep as isIterable, er as toEncoded$1, es as fail$1, et as schema, eu as fork, f as Note, fa as runForEachArray, fc as timeout, fd as join$1, ff as filter$4, fi as resolveDescription, fl as currentTimeMillis, fn as Number$2, fo as makeRecordUnsafe, fp as constVoid, fr as fromInput, fs as fromOption, ft as ResponseDefectEncoded, fu as isDeferred, g as OEmbed, ga as succeed$3, gc as tryPromise, gf as fromNullishOr, gi as passthrough$1, gl as StackTrace, gn as StringFromUriComponent, go as formatInet, gp as identity, gr as unwrap$1, gt as ServerClient, gu as failCause$1, h as NotesError, ha as scan, hc as transposeOption, hd as map$3, hf as flatten, hi as toEncoded, hl as IllegalArgumentError, hn as String$1, ho as NetAddressError, hp as flow, hr as toString$2, hs as ignore$1, ht as constPong, hu as fail$3, i as FileType, ia as mkUint8Array, ic as sleep, id as getSomes, if as getOrUndefinedUnsafe, ii as Union$1, il as startsWith, in as Json, io as fromInput$2, ip as isObject, ir as withDecodingDefault, is as flatMapEager, iu as provide$2, j as SignInParams, ja as make$37, jc as withTracerEnabled, jd as make$47, jf as toArray$1, ji as concat, jl as makeDieReason, jn as decodeUnknownEffect, jo as andThen, jr as set$3, js as matchCauseEffect, ju as DisablePropagation, k as OAuthTokenResponse, kc as withParentSpan, kd as empty$12, kf as orElseSome, ki as catchTags$1, kl as isNoSuchElementError, kn as decodeSync, ko as acquireRelease, kr as merge$2, ks as mapError, ku as reportCauseUnsafe, l as GitHubReadme, la as run$3, lc as tap$1, ld as isArrayNonEmpty, lf as all$2, li as null_, ll as parse$10, ln as NonEmptyArray, lo as Dns, lp as constFalse, lr as encodeUnknownEffect, ls as forkChild, lt as layerJson$1, lu as _await, m as NoteJson, ma as runLast, mc as timeoutOrElse, md as lastNonEmpty, mf as flatMapNullishOr, mi as string, mn as Redacted$1, mo as domainNameFromStringUnsafe, mp as dual, mr as setAll$1, ms as gen, mu as die, n as Capture, na as mergeAll$1, nc as scoped, nd as fromIterable$1, nf as get$6, ni as PropertySignature, nl as slice$2, nn as Finite, no as runIn, np as isNotNullish, nr as toType, ns as filterOrFail, nt as unwrap$4, nu as make$38, o as FxStatus, oa as orDie$1, oc as succeedNone, od as groupBy, of as make$41, oi as isNever, ol as trim, on as Literals, oo as gibibytes, op as isUndefined, or as isSchemaError, os as fnUntraced, ou as CurrentLogSpans, p as NoteId, pc as timeoutOption, pd as last$1, pf as flatMap$1, pi as resolveIdentifier, pl as currentTimeNanos, pn as Record$1, po as nameServerFromInput, pp as constant, pr as redactUrl, ps as fromResult, pt as constEof, pu as makeUnsafe$6, q as Port, qa as make$36, qc as includes, qd as minutes, qf as NodeInspectSymbol, qi as fromReadableStream, ql as sync$1, qn as makeFilter, qo as catch_, qr as toUint8Array$1, qs as raceFirst, qu as empty$11, r as Extraction, ra as mkString, rc as serviceOption, rd as get$8, rf as getOrUndefined$1, ri as Suspend, rl as split, rn as Int, ro as badArgument, rp as isNotUndefined, rr as withConstructorDefault, rs as flatMap, rt as withDefault, ru as makeUnsafe$4, s as GitHubComment, sa as pipeThroughChannel, sc as suspend, sd as head, sf as makeUnsafe$5, si as isOptional, sl as trimEnd, sn as MutableJson, so as mebibytes, sp as or$1, sr as omit, ss as forEach, st as RpcSerialization, t as RpcContracts, ta as mapError$1, tc as scope, td as flatMap$2, ti as Objects, tl as replaceAll, to as interruptAs, tp as isNotNull, tr as toJsonSchemaDocument, ts as failCause, tt as succeed$5, tu as forkUnsafe$1, u as GitHubRepo, ua as runCollect, uc as tapCause, ud as isReadonlyArrayEmpty, uf as contains$2, ui as optionalKey$1, un as Null, uo as DnsError, up as constTrue, ur as CurrentRedactedNames$1, us as forkIn, ut as layerSchemaBinary, uu as doneUnsafe, v as Reader, va as takeUntil, vc as uninterruptible, vd as prepend$2, vf as getOrElse, vi as transformOptional, vl as combine, vn as TaggedError$1, vo as formatUrlUnsafe, vp as pipeArguments, vr as has$3, vs as interruptible, vt as isWrapper, vu as isExit, w as AuthError, wa as last$2, wc as when$2, wd as takeRight, wf as liftThrowable, wi as toEpochMillis, wl as fromReasons, wn as Uint8ArrayFromBase64, wo as isLinkLocal, wr as empty$8, ws as logInfo, wt as Collector, wu as fiberEnterInterruptibleUnsafe, x as CurrentUser, xa as toReadableStreamEffect, xc as updateService, xd as some$2, xf as isNone, xi as encode$1, xl as fail$4, xn as URL$2, xo as ipFromStringUnsafe, xr as get$9, xs as logDebug, xt as isStreamSchema, xu as succeed$4, y as TikTokPage, ya as tap$2, yc as uninterruptibleMask, yd as reduce, yf as getOrNull, yi as decode$3, yl as die$1, yo as inetAddressFromIpString, yr as empty$13, ys as isEffect, yt as ClientAbort$1, yu as isFailure$1, za as offerAll, zc as passthrough, zd as match$3, zf as contA, zi as flatMap$3, zl as effectDiscard, zn as isGreaterThanOrEqualTo, zo as catchCause, zr as fromSetCookie, zs as option$1, zu as TaggedClass } from "./contracts-PzeJtyhG.mjs";
 import { createRequire } from "node:module";
 import { Duplex, Readable, pipeline } from "node:stream";
 import * as Http from "node:http";
@@ -13705,6 +13705,13 @@ const COOKIE = {
 };
 const SESSION_DURATION = days(365);
 const OAUTH_DURATION = minutes(10);
+const DEVELOPMENT_USER = User.make({
+	id: "development",
+	name: "Developer"
+});
+const MOCK_AUTH = { verify: fn$1("Auth.verify")(function* (_token) {
+	return yield* succeed$1(DEVELOPMENT_USER);
+}) };
 Uint8Array.from([
 	48,
 	46,
@@ -13743,9 +13750,10 @@ function respond(message, handler) {
 		onTrue: () => 401
 	}) })));
 }
-function userFrom(auth, headers) {
-	return pipe(get$7(headers, "authorization"), filter$4(startsWith("Bearer ")), map$5(replace$1("Bearer ", "")), orElse$2(() => pipe(get$7(headers, "cookie"), flatMapNullishOr((cookie) => parseHeader(cookie)[SESSION_COOKIE]))), fromOption, rejected("Sign in first"), flatMap((token) => auth.verify(token)));
-}
+const userFrom = fnUntraced(function* (auth, headers) {
+	if (yield* development) return DEVELOPMENT_USER;
+	return yield* pipe(get$7(headers, "authorization"), filter$4(startsWith("Bearer ")), map$5(replace$1("Bearer ", "")), orElse$2(() => pipe(get$7(headers, "cookie"), flatMapNullishOr((cookie) => parseHeader(cookie)[SESSION_COOKIE]))), fromOption, rejected("Sign in first"), flatMap((token) => auth.verify(token)));
+});
 function provide(auth) {
 	return pipe(make$41(Auth, auth), add$1(RpcAuth, RpcAuth.of((effect, request) => flatMap(userFrom(auth, request.headers), (user) => provideService(effect, CurrentUser, user)))));
 }
@@ -13769,7 +13777,7 @@ const SameOrigin = middleware((httpEffect) => gen(function* () {
 	});
 	if (exists(get$7(request.headers, "origin"), (origin) => origin !== `${scheme}://${request.headers["host"] ?? ""}`)) return text$2("The request comes from another origin", { status: 403 });
 	return yield* httpEffect;
-}), { global: true });
+})).layer;
 function parentDomain(request) {
 	return pipe(toURL(request), map$5((url) => pipe(url.hostname, split("."), drop(1), join$1("."))), filter$4(isNonEmpty));
 }
@@ -13837,6 +13845,7 @@ fnUntraced(function* (issuer, config, redirects) {
 });
 var Auth = class Auth extends Service()("@deslop/auth/service/Auth") {
 	static layer = merge$3(SameOrigin, effectContext(gen(function* () {
+		if (yield* development) return provide(Auth.of(MOCK_AUTH));
 		const client = filterStatusOk(yield* HttpClient);
 		const url = yield* pipe(String$2("AUTH_URL"), withDefault(AUTH_URL));
 		const read = pipe(client.get(`${url}/auth/keys`), flatMap(schemaBodyJson$1(Verification)), flatMap((verification) => map$1(pipe(fromResult(decode$3(verification.key)), flatMap((key) => tryPromise(() => crypto.subtle.importKey("raw", new Uint8Array(key), { name: "Ed25519" }, false, ["verify"])))), (publicKey) => ({
@@ -13855,8 +13864,15 @@ Service()("@deslop/auth/service/Issuer");
 const HttpAuth = middleware()(gen(function* () {
 	const auth = yield* Auth;
 	return (httpEffect) => gen(function* () {
-		const user = yield* result$1(userFrom(auth, (yield* HttpServerRequest).headers));
-		if (isFailure(user)) return yield* as$1(logWarning("Sign in first", user.failure), text$2("Sign in first", { status: 401 }));
+		const request = yield* HttpServerRequest;
+		const user = yield* result$1(userFrom(auth, request.headers));
+		if (isFailure(user)) {
+			if (includes("text/html")(request.headers["accept"] ?? "")) return redirect(`${AUTH_URL}/auth/github?${toString$2(fromInput({ redirect: match$1(toURL(request), {
+				onNone: () => "/",
+				onSome: (url) => url.href
+			}) }))}`);
+			return yield* as$1(logWarning("Sign in first", user.failure), text$2("Sign in first", { status: 401 }));
+		}
 		return yield* provideService(httpEffect, CurrentUser, user.success);
 	});
 }));
@@ -14495,20 +14511,32 @@ const SpanKind = {
 };
 //#endregion
 //#region ../../packages/runtime/src/telemetry.ts
-function layerOtlp(serviceName, url) {
-	const resource = { serviceName };
-	return pipe(mergeAll(layer$1({
-		resource,
-		url: new URL("/v1/traces", url).href
-	}), layer$2({
-		resource,
-		url: new URL("/v1/logs", url).href
-	})), provide$1([layerJson, layer$6]));
+function layerOtlp(serviceName, url, runtime) {
+	return unwrap$3(gen(function* () {
+		const start = `${yield* currentTimeNanos}`;
+		const resource = {
+			attributes: {
+				"scope.run.started_unix_nano": start,
+				"scope.runtime": runtime,
+				"service.instance.id": start
+			},
+			serviceName
+		};
+		return pipe(mergeAll(layer$1({
+			exportInterval: "250 millis",
+			resource,
+			url: new URL("/v1/traces", url).href
+		}), layer$2({
+			exportInterval: "250 millis",
+			resource,
+			url: new URL("/v1/logs", url).href
+		})), provide$1([layerJson, layer$6]));
+	}));
 }
 //#endregion
 //#region ../../packages/runtime/src/server.ts
 function layer(applicationName) {
-	return mergeAll(unwrap$3(map$1(pipe(URL$1("VITE_OTEL_URL"), withDefault(new URL("http://localhost:4318"))), (url) => layerOtlp(`${applicationName}-server`, url))), layerSchemaBinary());
+	return mergeAll(unwrap$3(map$1(pipe(URL$1("VITE_OTEL_URL"), withDefault(new URL("http://localhost:4318"))), (url) => layerOtlp(`${applicationName}-server`, url, "server"))), layerSchemaBinary());
 }
 layer$3({
 	index: "index.html",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deslop/stash",
-  "version": "0.1.1092",
+  "version": "0.1.1095",
   "description": "A personal inbox for links and notes: the server, the iOS app, and a CLI that saves to it.",
   "repository": {
     "type": "git",
@@ -19,7 +19,7 @@
   "imports": {
     "#lib/*": "./src/lib/*",
     "#modules/*": "./modules/*",
-    "#package": "./package.json",
+    "#package.*": "./package.*",
     "#routes/*": "./src/routes/*",
     "#rpcs/*": "./src/rpcs/*",
     "#services/*": "./src/services/*"