ambral 0.4.0 → 0.5.0

package/dist/ambral.js

@@ -215,6 +215,7 @@ var constFalse = /* @__PURE__ */ constant(false);
 var constNull = /* @__PURE__ */ constant(null);
 var constUndefined = /* @__PURE__ */ constant(undefined);
 var constVoid = constUndefined;
+var compose = /* @__PURE__ */ dual(2, (ab, bc) => (a) => bc(ab(a)));
 function pipe(a, ...args) {
   return pipeArguments(a, args);
 }
@@ -360,7 +361,7 @@ __export(exports_Predicate, {
   hasProperty: () => hasProperty,
   every: () => every,
   eqv: () => eqv,
-  compose: () => compose,
+  compose: () => compose2,
   and: () => and,
   Tuple: () => Tuple,
   Struct: () => Struct
@@ -457,7 +458,7 @@ function isPromiseLike(input) {
 function isRegExp(input) {
   return input instanceof RegExp;
 }
-var compose = /* @__PURE__ */ dual(2, (ab, bc) => (a) => ab(a) && bc(a));
+var compose2 = /* @__PURE__ */ dual(2, (ab, bc) => (a) => ab(a) && bc(a));
 function Tuple(elements) {
   return (as) => {
     for (let i = 0;i < elements.length; i++) {
@@ -4783,6 +4784,13 @@ class ParentSpan extends (/* @__PURE__ */ Service()(ParentSpanKey, {
 })) {
 }
 var make9 = (options) => options;
+var externalSpan = (options) => ({
+  _tag: "ExternalSpan",
+  spanId: options.spanId,
+  traceId: options.traceId,
+  sampled: options.sampled ?? true,
+  annotations: options.annotations ?? empty()
+});
 var DisablePropagation = /* @__PURE__ */ Reference("effect/Tracer/DisablePropagation", {
   defaultValue: constFalse
 });
@@ -6681,6 +6689,12 @@ var fiberEnterUninterruptibleUnsafe = (fiber2) => {
   impl.interruptible = false;
   impl._stack.push(setInterruptibleTrue);
 };
+var fiberEnterInterruptibleUnsafe = (fiber2) => {
+  const impl = fiber2;
+  if (impl.interruptible)
+    return;
+  return setFiberInterruptible(impl);
+};
 var interruptible = (self) => withFiber((fiber2) => {
   if (fiber2.interruptible)
     return self;
@@ -8260,6 +8274,7 @@ var addFinalizer2 = scopeAddFinalizer;
 var fork = scopeFork;
 var forkUnsafe2 = scopeForkUnsafe;
 var close = scopeClose;
+var closeUnsafe = scopeCloseUnsafe;
 
 // ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/Layer.js
 var TypeId7 = "~effect/Layer";
@@ -18148,7 +18163,7 @@ var runGetter = (self, input, options) => {
 };
 var makeGetter = (fields) => Object.assign(Object.create(Prototype), fields);
 var composeOptionalEffect = (first, second) => transformOptionalEffect((input, options) => flatMapEager2(runGetter(first, input, options), (output) => runGetter(second, output, options)));
-var compose2 = /* @__PURE__ */ dual(2, (self, other) => {
+var compose3 = /* @__PURE__ */ dual(2, (self, other) => {
   if (self._tag === "Passthrough")
     return other;
   if (other._tag === "Passthrough")
@@ -18753,7 +18768,7 @@ var Transformation = class extends Class {
     return new Transformation(this.encode, this.decode);
   }
 };
-var composeTransformation = /* @__PURE__ */ dual(2, (self, other) => new Transformation(compose2(self.decode, other.decode), compose2(other.encode, self.encode)));
+var composeTransformation = /* @__PURE__ */ dual(2, (self, other) => new Transformation(compose3(self.decode, other.decode), compose3(other.encode, self.encode)));
 function isTransformation(u) {
   return hasProperty(u, TypeId31) && u[TypeId31] === TypeId31;
 }
@@ -28094,7 +28109,7 @@ class CheckNode {
     this.get = (s) => runChecks(checks, s);
   }
 }
-function compose3(a, b) {
+function compose4(a, b) {
   if (a.length === 0)
     return b;
   if (b.length === 0)
@@ -28133,13 +28148,13 @@ class OptionalImpl {
     return (s) => getOrElse3(flatMap2(this.getResult(s), (a) => this.replaceResult(f(a), s)), () => s);
   }
   compose(that) {
-    return make41(compose3(this.node, that.node));
+    return make41(compose4(this.node, that.node));
   }
   key(key) {
-    return make41(compose3(this.node, [new PathNode([key])]));
+    return make41(compose4(this.node, [new PathNode([key])]));
   }
   optionalKey(key) {
-    return make41(compose3(this.node, primitiveNode("Lens", (s) => s[key], (a, s) => {
+    return make41(compose4(this.node, primitiveNode("Lens", (s) => s[key], (a, s) => {
       const copy5 = cloneShallow(s);
       if (a === undefined) {
         if (Array.isArray(copy5) && (typeof key === "number" || typeof key === "string" && isCanonicalArrayIndex(key))) {
@@ -28154,20 +28169,20 @@ class OptionalImpl {
     })));
   }
   check(...checks) {
-    return make41(compose3(this.node, [new CheckNode(checks)]));
+    return make41(compose4(this.node, [new CheckNode(checks)]));
   }
   refine(refinement, annotations2) {
-    return make41(compose3(this.node, [new CheckNode([makeFilterByGuard(refinement, annotations2)])]));
+    return make41(compose4(this.node, [new CheckNode([makeFilterByGuard(refinement, annotations2)])]));
   }
   tag(tag) {
     const err = fail2(new InvalidValue({
       expected: `${JSON.stringify(tag)} tag`
     }));
-    return make41(compose3(this.node, primitiveNode("Prism", (s) => s._tag === tag ? succeed2(s) : err, identity)));
+    return make41(compose4(this.node, primitiveNode("Prism", (s) => s._tag === tag ? succeed2(s) : err, identity)));
   }
   at(key, ..._rest) {
     const err = fail2(new Pointer([key], new MissingKey(undefined)));
-    return make41(compose3(this.node, primitiveNode("Optional", (s) => Object.hasOwn(s, key) ? succeed2(s[key]) : err, (a, s) => {
+    return make41(compose4(this.node, primitiveNode("Optional", (s) => Object.hasOwn(s, key) ? succeed2(s[key]) : err, (a, s) => {
       if (Object.hasOwn(s, key)) {
         const copy5 = cloneShallow(s);
         assignProperty(copy5, key, a);
@@ -28845,6 +28860,22 @@ var formatInet = (self) => {
   const host = formatHost(self);
   return isInetAddressV4(self) ? `${host}:${self.port}` : `[${host}]:${self.port}`;
 };
+var formatUrlHost = (self) => isIpv4Address(self) ? formatIp(self) : `[${formatIp(self)}]`;
+var toUrl = (self, scheme = "http") => {
+  if (self._tag === "InetAddressV6" && self.scopeId !== 0) {
+    return addressError(self, "scoped IPv6 addresses are not supported by WHATWG URLs");
+  }
+  return try_({
+    try: () => new URL(`${scheme}://${isInetAddress(self) ? formatInet(self) : formatUrlHost(self)}`),
+    catch: (cause) => new NetAddressError({
+      input: self,
+      message: "failed to construct URL",
+      cause
+    })
+  });
+};
+var formatUrl = (self, scheme = "http") => isUnixPathAddress(self) ? succeed2(formatUnixPath(self)) : map2(toUrl(self, scheme), (url) => `${url.protocol}//${url.host}`);
+var formatUrlUnsafe = (self, scheme = "http") => getOrThrow2(formatUrl(self, scheme));
 var UnixPathProto = {
   ...BaseProto,
   _tag: "UnixPathAddress",
@@ -28867,6 +28898,7 @@ var unixPathAddress = (path) => {
   self.path = path;
   return Object.freeze(self);
 };
+var formatUnixPath = (self) => `unix://${self.path}`;
 
 // ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/net/Host.js
 var TypeId43 = "~effect/net/Host";
@@ -33627,7 +33659,7 @@ function Array3(value3, pathOrOptions, options) {
   const separator = resolvedOptions?.separator ?? ",";
   const arrayString = String7.pipe(decodeTo2(toCodecStringTree2(array2), {
     decode: split3(resolvedOptions),
-    encode: compose2(passthrough2({
+    encode: compose3(passthrough2({
       strict: false
     }), transform((input) => input.join(separator)))
   }));
@@ -33639,7 +33671,7 @@ function Record4(key, value3, pathOrOptions, options) {
   const split4 = splitKeyValue2(hasPath ? options : pathOrOptions);
   const recordString = String7.pipe(decodeTo2(toCodecStringTree2(record2), {
     decode: split4.decode,
-    encode: compose2(passthrough2({
+    encode: compose3(passthrough2({
       strict: false
     }), split4.encode)
   }));
@@ -34801,7 +34833,7 @@ __export(exports_HttpClientRequest, {
   trace: () => trace2,
   toWebResult: () => toWebResult,
   toWeb: () => toWeb,
-  toUrl: () => toUrl,
+  toUrl: () => toUrl2,
   setUrlParams: () => setUrlParams,
   setUrlParam: () => setUrlParam,
   setUrl: () => setUrl,
@@ -35028,7 +35060,7 @@ var bodyFormData = /* @__PURE__ */ dual(2, (self, body) => setBody(self, formDat
 var bodyFormDataRecord = /* @__PURE__ */ dual(2, (self, entries3) => setBody(self, formDataRecord(entries3)));
 var bodyStream = /* @__PURE__ */ dual((args2) => isHttpClientRequest(args2[0]), (self, body, options2) => setBody(self, stream(body, options2?.contentType, options2?.contentLength)));
 var bodyFile = /* @__PURE__ */ dual((args2) => isHttpClientRequest(args2[0]), (self, path, options2) => map9(file(path, options2), (body) => setBody(self, body)));
-function toUrl(self) {
+function toUrl2(self) {
   const r = make50(self.url, self.urlParams, getOrUndefined(self.hash));
   if (isSuccess2(r)) {
     return some3(r.success);
@@ -35187,7 +35219,7 @@ class WebHttpClientResponse extends Class2 {
   get url() {
     if (this.source.url)
       return this.source.url.split("#")[0];
-    const url = toUrl(this.request);
+    const url = toUrl2(this.request);
     if (isNone2(url))
       return "";
     url.value.hash = "";
@@ -35295,6 +35327,70 @@ var toHeaders = (span3) => fromRecordUnsafe({
   })}`,
   traceparent: `00-${span3.traceId}-${span3.spanId}-${span3.sampled ? "01" : "00"}`
 });
+var fromHeaders = (headers) => {
+  let span3 = w3c(headers);
+  if (isSome2(span3)) {
+    return span3;
+  }
+  span3 = b3(headers);
+  if (isSome2(span3)) {
+    return span3;
+  }
+  return xb3(headers);
+};
+var b3 = (headers) => {
+  if (!("b3" in headers)) {
+    return none2();
+  }
+  const parts2 = headers["b3"].split("-");
+  if (parts2.length < 2 || isB3Ids(parts2[0], parts2[1]) === false) {
+    return none2();
+  }
+  return some3(externalSpan({
+    traceId: parts2[0],
+    spanId: parts2[1],
+    sampled: parts2[2] ? parts2[2] === "1" || parts2[2] === "d" : true
+  }));
+};
+var xb3 = (headers) => {
+  if (!headers["x-b3-traceid"] || !headers["x-b3-spanid"] || isB3Ids(headers["x-b3-traceid"], headers["x-b3-spanid"]) === false) {
+    return none2();
+  }
+  return some3(externalSpan({
+    traceId: headers["x-b3-traceid"],
+    spanId: headers["x-b3-spanid"],
+    sampled: headers["x-b3-flags"] === "1" || (headers["x-b3-sampled"] ? headers["x-b3-sampled"] === "1" || headers["x-b3-sampled"] === "true" : true)
+  }));
+};
+var w3cTraceId = /^[0-9a-f]{32}$/i;
+var w3cSpanId = /^[0-9a-f]{16}$/i;
+var b3TraceId = /^(?:[0-9a-f]{16}|[0-9a-f]{32})$/i;
+var isB3Ids = (traceId, spanId) => b3TraceId.test(traceId) && w3cSpanId.test(spanId);
+var w3c = (headers) => {
+  if (!headers["traceparent"]) {
+    return none2();
+  }
+  const parts2 = headers["traceparent"].split("-");
+  if (parts2.length !== 4) {
+    return none2();
+  }
+  const [version, traceId, spanId, flags] = parts2;
+  switch (version) {
+    case "00": {
+      if (w3cTraceId.test(traceId) === false || w3cSpanId.test(spanId) === false || traceId === "00000000000000000000000000000000" || spanId === "0000000000000000") {
+        return none2();
+      }
+      return some3(externalSpan({
+        traceId,
+        spanId,
+        sampled: (parseInt(flags, 16) & 1) === 1
+      }));
+    }
+    default: {
+      return none2();
+    }
+  }
+};
 
 // ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/http/internal/tracing.js
 var defaultPorts = {
@@ -35909,155 +36005,859 @@ var fetch = /* @__PURE__ */ make52((request3, url, signal, fiber3) => {
   return send(undefined);
 });
 var layer14 = /* @__PURE__ */ layerMergedContext(/* @__PURE__ */ succeed6(fetch));
-// ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/http/HttpServerRequest.js
-var exports_HttpServerRequest = {};
-__export(exports_HttpServerRequest, {
-  upgradeChannel: () => upgradeChannel,
-  toWebResult: () => toWebResult2,
-  toWeb: () => toWeb3,
-  toURL: () => toURL,
-  toClientRequest: () => toClientRequest,
-  searchParamsFromURL: () => searchParamsFromURL,
-  schemaSearchParams: () => schemaSearchParams,
-  schemaHeaders: () => schemaHeaders,
-  schemaCookies: () => schemaCookies,
-  schemaBodyUrlParams: () => schemaBodyUrlParams2,
-  schemaBodyMultipart: () => schemaBodyMultipart,
-  schemaBodyJson: () => schemaBodyJson3,
-  schemaBodyFormJson: () => schemaBodyFormJson,
-  schemaBodyForm: () => schemaBodyForm,
-  fromWeb: () => fromWeb4,
-  fromClientRequest: () => fromClientRequest,
-  TypeId: () => TypeId60,
-  ParsedSearchParams: () => ParsedSearchParams,
-  MaxBodySize: () => MaxBodySize,
-  HttpServerRequest: () => HttpServerRequest
-});
-
-// ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/socket/Socket.js
-var encoder5 = /* @__PURE__ */ new TextEncoder;
-var readerBytes = (self) => map9(self.reader, ({
-  pull
-}) => map9(pull, (chunk) => {
-  for (let i = 0;i < chunk.length; i++) {
-    if (typeof chunk[i] === "string") {
-      const out = new Array(chunk.length);
-      for (let j = 0;j < chunk.length; j++) {
-        const item = chunk[j];
-        out[j] = typeof item === "string" ? encoder5.encode(item) : item;
+// ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/http/HttpRouter.js
+var exports_HttpRouter = {};
+__export(exports_HttpRouter, {
+  use: () => use,
+  toWebHandler: () => toWebHandler,
+  toHttpEffect: () => toHttpEffect,
+  serve: () => serve2,
+  schemaPathParams: () => schemaPathParams,
+  schemaParams: () => schemaParams,
+  schemaNoBody: () => schemaNoBody,
+  schemaJson: () => schemaJson3,
+  route: () => route,
+  provideRequest: () => provideRequest,
+  prefixRoute: () => prefixRoute,
+  prefixPath: () => prefixPath,
+  params: () => params,
+  middleware: () => middleware,
+  make: () => make61,
+  layer: () => layer15,
+  disableLogger: () => disableLogger,
+  cors: () => cors2,
+  addAll: () => addAll,
+  add: () => add5,
+  RouterConfig: () => RouterConfig,
+  RouteContext: () => RouteContext,
+  HttpRouter: () => HttpRouter
+});
+
+// ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/http/FindMyWay/internal/queryString.js
+var plusRegex = /\+/g;
+var Empty3 = function() {};
+Empty3.prototype = /* @__PURE__ */ Object.create(null);
+function parse2(input) {
+  const result6 = new Empty3;
+  if (typeof input !== "string") {
+    return result6;
+  }
+  const inputLength = input.length;
+  let key = "";
+  let value5 = "";
+  let startingIndex = -1;
+  let equalityIndex = -1;
+  let shouldDecodeKey = false;
+  let shouldDecodeValue = false;
+  let keyHasPlus = false;
+  let valueHasPlus = false;
+  let hasBothKeyValuePair = false;
+  let c = 0;
+  for (let i = 0;i < inputLength + 1; i++) {
+    c = i !== inputLength ? input.charCodeAt(i) : 38;
+    if (c === 38) {
+      hasBothKeyValuePair = equalityIndex > startingIndex;
+      if (!hasBothKeyValuePair) {
+        equalityIndex = i;
+      }
+      key = input.slice(startingIndex + 1, equalityIndex);
+      if (hasBothKeyValuePair || key.length > 0) {
+        if (keyHasPlus) {
+          key = key.replace(plusRegex, " ");
+        }
+        if (shouldDecodeKey) {
+          try {
+            key = decodeURIComponent(key) || key;
+          } catch {}
+        }
+        if (hasBothKeyValuePair) {
+          value5 = input.slice(equalityIndex + 1, i);
+          if (valueHasPlus) {
+            value5 = value5.replace(plusRegex, " ");
+          }
+          if (shouldDecodeValue) {
+            try {
+              value5 = decodeURIComponent(value5) || value5;
+            } catch {}
+          }
+        }
+        const currentValue = result6[key];
+        if (currentValue === undefined) {
+          result6[key] = value5;
+        } else {
+          if (currentValue.pop) {
+            currentValue.push(value5);
+          } else {
+            result6[key] = [currentValue, value5];
+          }
+        }
+      }
+      value5 = "";
+      startingIndex = i;
+      equalityIndex = i;
+      shouldDecodeKey = false;
+      shouldDecodeValue = false;
+      keyHasPlus = false;
+      valueHasPlus = false;
+    } else if (c === 61) {
+      if (equalityIndex <= startingIndex) {
+        equalityIndex = i;
+      } else {
+        shouldDecodeValue = true;
+      }
+    } else if (c === 43) {
+      if (equalityIndex > startingIndex) {
+        valueHasPlus = true;
+      } else {
+        keyHasPlus = true;
+      }
+    } else if (c === 37) {
+      if (equalityIndex > startingIndex) {
+        shouldDecodeValue = true;
+      } else {
+        shouldDecodeKey = true;
       }
-      return out;
     }
   }
-  return chunk;
-}));
-var CloseEventTypeId = "~effect/socket/Socket/CloseEvent";
-var isCloseEvent = (u) => hasProperty(u, CloseEventTypeId);
-var SocketErrorTypeId = "~effect/socket/Socket/SocketError";
-var isSocketError = (u) => hasProperty(u, SocketErrorTypeId);
-
-class SocketReadError extends (/* @__PURE__ */ Error4("effect/socket/Socket/SocketReadError")({
-  _tag: /* @__PURE__ */ tag("SocketReadError"),
-  cause: /* @__PURE__ */ Defect()
-})) {
-  message = `An error occurred during Read`;
+  return result6;
 }
 
-class SocketWriteError extends (/* @__PURE__ */ Error4("effect/socket/Socket/SocketWriteError")({
-  _tag: /* @__PURE__ */ tag("SocketWriteError"),
-  cause: /* @__PURE__ */ Defect()
-})) {
-  message = `An error occurred during Write`;
+// ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/http/FindMyWay/internal/router.js
+var FULL_PATH_REGEXP = /^https?:\/\/.*?\//;
+var OPTIONAL_PARAM_REGEXP = /(\/:[^/()]*?)\?(\/?)/;
+var emptyParamsArray = [];
+var CLEAN_SINGLE_PARAM_REGEXP = /^[^:*(]*\/:[^/:*(.-]+$/;
+var isCleanSingleTrailingParam = (path) => CLEAN_SINGLE_PARAM_REGEXP.test(path);
+var make53 = (options3 = {}) => new RouterImpl(options3);
+
+class RouterImpl {
+  constructor(options3 = {}) {
+    this.options = {
+      ignoreTrailingSlash: true,
+      ignoreDuplicateSlashes: true,
+      caseSensitive: false,
+      maxParamLength: 100,
+      ...options3
+    };
+  }
+  options;
+  routes = [];
+  trees = /* @__PURE__ */ Object.create(null);
+  staticRoutes = /* @__PURE__ */ Object.create(null);
+  singleParamRoutes = /* @__PURE__ */ Object.create(null);
+  singleParamDisabled = /* @__PURE__ */ Object.create(null);
+  brothersNodesStack = [];
+  singleParamArray = [""];
+  on(method, path, handler) {
+    const optionalParamMatch = path.match(OPTIONAL_PARAM_REGEXP);
+    if (optionalParamMatch && optionalParamMatch.index !== undefined) {
+      assert2(path.length === optionalParamMatch.index + optionalParamMatch[0].length, "Optional Parameter needs to be the last parameter of the path");
+      const pathFull = path.replace(OPTIONAL_PARAM_REGEXP, "$1$2");
+      const pathOptional = path.replace(OPTIONAL_PARAM_REGEXP, "$2") || "/";
+      this.on(method, pathFull, handler);
+      this.on(method, pathOptional, handler);
+      return;
+    }
+    if (this.options.ignoreDuplicateSlashes) {
+      path = removeDuplicateSlashes(path);
+    }
+    if (this.options.ignoreTrailingSlash) {
+      path = trimLastSlash(path);
+    }
+    const methods = typeof method === "string" ? [method] : method;
+    for (const method2 of methods) {
+      this._on(method2, path, handler);
+    }
+  }
+  all(path, handler) {
+    this.on(httpMethods, path, handler);
+  }
+  _on(method, path, handler) {
+    if (this.trees[method] === undefined) {
+      this.trees[method] = new StaticNode("/");
+    }
+    let pattern = path;
+    if (pattern === "*" && this.trees[method].prefix.length !== 0) {
+      const currentRoot = this.trees[method];
+      this.trees[method] = new StaticNode("");
+      this.trees[method].staticChildren["/"] = currentRoot;
+    }
+    let parentNodePathIndex = this.trees[method].prefix.length;
+    let currentNode = this.trees[method];
+    const params = [];
+    for (let i = 0;i <= pattern.length; i++) {
+      if (pattern.charCodeAt(i) === 58 && pattern.charCodeAt(i + 1) === 58) {
+        i++;
+        continue;
+      }
+      const isParametricNode = pattern.charCodeAt(i) === 58 && pattern.charCodeAt(i + 1) !== 58;
+      const isWildcardNode = pattern.charCodeAt(i) === 42;
+      if (isParametricNode || isWildcardNode || i === pattern.length && i !== parentNodePathIndex) {
+        let staticNodePath = pattern.slice(parentNodePathIndex, i);
+        if (!this.options.caseSensitive) {
+          staticNodePath = staticNodePath.toLowerCase();
+        }
+        staticNodePath = staticNodePath.split("::").join(":");
+        staticNodePath = staticNodePath.split("%").join("%25");
+        currentNode = currentNode.createStaticChild(staticNodePath);
+      }
+      if (isParametricNode) {
+        let isRegexNode = false;
+        let isParamSafe = true;
+        let backtrack = "";
+        const regexps = [];
+        let nodePatternParts = "";
+        let lastParamStartIndex = i + 1;
+        for (let j = lastParamStartIndex;; j++) {
+          const charCode = pattern.charCodeAt(j);
+          const isRegexParam = charCode === 40;
+          const isStaticPart = charCode === 45 || charCode === 46;
+          const isEndOfNode = charCode === 47 || j === pattern.length;
+          if (isRegexParam || isStaticPart || isEndOfNode) {
+            const paramName = pattern.slice(lastParamStartIndex, j);
+            params.push(paramName);
+            isRegexNode = isRegexNode || isRegexParam || isStaticPart;
+            if (isRegexParam) {
+              const endOfRegexIndex = getClosingParenthensePosition(pattern, j);
+              const regexString = pattern.slice(j, endOfRegexIndex + 1);
+              regexps.push(trimRegExpStartAndEnd(regexString));
+              j = endOfRegexIndex + 1;
+              isParamSafe = true;
+            } else {
+              regexps.push(isParamSafe ? "(.*?)" : `(${backtrack}|(?:(?!${backtrack}).)*)`);
+              isParamSafe = false;
+            }
+            const staticPartStartIndex = j;
+            for (;j < pattern.length; j++) {
+              const charCode2 = pattern.charCodeAt(j);
+              if (charCode2 === 47)
+                break;
+              if (charCode2 === 58) {
+                const nextCharCode = pattern.charCodeAt(j + 1);
+                if (nextCharCode === 58)
+                  j++;
+                else
+                  break;
+              }
+            }
+            let staticPart = pattern.slice(staticPartStartIndex, j);
+            if (staticPart) {
+              staticPart = staticPart.split("::").join(":");
+              staticPart = staticPart.split("%").join("%25");
+              regexps.push(backtrack = escapeRegExp(staticPart));
+            }
+            lastParamStartIndex = j + 1;
+            nodePatternParts += "()" + staticPart;
+            if (isEndOfNode || pattern.charCodeAt(j) === 47 || j === pattern.length) {
+              const nodePattern = isRegexNode ? nodePatternParts : staticPart;
+              const nodePath = pattern.slice(i, j);
+              pattern = pattern.slice(0, i + 1) + nodePattern + pattern.slice(j);
+              i += nodePattern.length;
+              const regex = isRegexNode ? new RegExp("^" + regexps.join("") + "$") : undefined;
+              currentNode = currentNode.createParametricChild(regex, staticPart, nodePath);
+              parentNodePathIndex = i + 1;
+              break;
+            }
+          }
+        }
+      } else if (isWildcardNode) {
+        params.push("*");
+        currentNode = currentNode.createWildcardChild();
+        parentNodePathIndex = i + 1;
+        if (i !== pattern.length - 1) {
+          throw new Error("Wildcard must be the last character in the route");
+        }
+      }
+    }
+    if (!this.options.caseSensitive) {
+      pattern = pattern.toLowerCase();
+    }
+    if (pattern === "*") {
+      pattern = "/*";
+    }
+    for (const existRoute of this.routes) {
+      if (existRoute.method === method && existRoute.pattern === pattern) {
+        throw new Error(`Method '${method}' already declared for route '${pattern}'`);
+      }
+    }
+    const route = {
+      method,
+      path,
+      pattern,
+      params,
+      handler
+    };
+    this.routes.push(route);
+    currentNode.addRoute(route);
+    if (params.length === 0) {
+      const staticKey = pattern.split("::").join(":").split("%").join("%25");
+      const store = this.staticRoutes[method] ??= new Map;
+      if (!store.has(staticKey)) {
+        store.set(staticKey, currentNode.handlerStorage.unconstrainedHandler);
+      }
+    } else if (isCleanSingleTrailingParam(path)) {
+      if (this.singleParamDisabled[method] !== true) {
+        let prefix3 = path.slice(0, path.indexOf(":"));
+        if (!this.options.caseSensitive) {
+          prefix3 = prefix3.toLowerCase();
+        }
+        prefix3 = prefix3.split("%").join("%25");
+        const store = this.singleParamRoutes[method] ??= new Map;
+        if (!store.has(prefix3)) {
+          store.set(prefix3, currentNode.handlerStorage.unconstrainedHandler);
+        }
+      }
+    } else if (/[(*]|[^/]:|:[^/]*[-.]/.test(path)) {
+      this.singleParamDisabled[method] = true;
+      delete this.singleParamRoutes[method];
+    }
+  }
+  has(method, path) {
+    const node = this.trees[method];
+    if (node === undefined) {
+      return false;
+    }
+    const staticNode = node.getStaticChild(path);
+    if (staticNode === undefined) {
+      return false;
+    }
+    return staticNode.isLeafNode;
+  }
+  find(method, path) {
+    let currentNode = this.trees[method];
+    if (currentNode === undefined)
+      return;
+    let querystring = "";
+    let shouldDecodeParam = false;
+    let clean = path.charCodeAt(0) === 47 && (path.length === 1 || path.charCodeAt(path.length - 1) !== 47);
+    if (clean) {
+      for (let i = 1;i < path.length; i++) {
+        const code = path.charCodeAt(i);
+        if (code === 37 || code === 63 || code === 59 || code === 35 || code >= 65 && code <= 90 || code === 47 && path.charCodeAt(i - 1) === 47) {
+          clean = false;
+          break;
+        }
+      }
+    }
+    if (!clean) {
+      if (path.charCodeAt(0) !== 47) {
+        path = path.replace(FULL_PATH_REGEXP, "/");
+      }
+      let sanitizedUrl;
+      try {
+        sanitizedUrl = safeDecodeURI(path);
+        path = sanitizedUrl.path;
+        querystring = sanitizedUrl.querystring;
+        shouldDecodeParam = sanitizedUrl.shouldDecodeParam;
+      } catch (error2) {
+        return;
+      }
+      if (this.options.ignoreDuplicateSlashes) {
+        path = removeDuplicateSlashes(path);
+      }
+      if (this.options.ignoreTrailingSlash) {
+        path = trimLastSlash(path);
+      }
+    }
+    const originPath = path;
+    if (!clean && this.options.caseSensitive === false) {
+      path = path.toLowerCase();
+    }
+    const maxParamLength = this.options.maxParamLength;
+    const staticStore = this.staticRoutes[method];
+    if (staticStore !== undefined) {
+      const handle = staticStore.get(path);
+      if (handle !== undefined) {
+        return {
+          handler: handle.handler,
+          params: handle.createParams(emptyParamsArray),
+          searchParams: parse2(querystring)
+        };
+      }
+    }
+    const singleParamStore = this.singleParamRoutes[method];
+    if (singleParamStore !== undefined) {
+      const prefixLength = path.lastIndexOf("/") + 1;
+      const handle = singleParamStore.get(path.slice(0, prefixLength));
+      if (handle !== undefined && path.length > prefixLength) {
+        let param = originPath.slice(prefixLength);
+        if (shouldDecodeParam) {
+          param = safeDecodeURIComponent(param);
+        }
+        if (param.length <= maxParamLength) {
+          this.singleParamArray[0] = param;
+          return {
+            handler: handle.handler,
+            params: handle.createParams(this.singleParamArray),
+            searchParams: parse2(querystring)
+          };
+        }
+      }
+    }
+    let pathIndex = currentNode.prefix.length;
+    const params = [];
+    const pathLen = path.length;
+    const brothersNodesStack = this.brothersNodesStack;
+    brothersNodesStack.length = 0;
+    while (true) {
+      if (pathIndex === pathLen && currentNode.isLeafNode) {
+        const handle = currentNode.handlerStorage?.find();
+        if (handle !== undefined) {
+          return {
+            handler: handle.handler,
+            params: handle.createParams(params),
+            searchParams: parse2(querystring)
+          };
+        }
+      }
+      let node = currentNode.getNextNode(path, pathIndex, brothersNodesStack, params.length);
+      if (node === undefined) {
+        if (brothersNodesStack.length === 0) {
+          return;
+        }
+        const brotherNodeState = brothersNodesStack.pop();
+        pathIndex = brotherNodeState.brotherPathIndex;
+        params.splice(brotherNodeState.paramsCount);
+        node = brotherNodeState.brotherNode;
+      }
+      currentNode = node;
+      while (true) {
+        if (currentNode._tag === "StaticNode") {
+          pathIndex += currentNode.prefix.length;
+          break;
+        }
+        if (currentNode._tag === "WildcardNode") {
+          let param2 = originPath.slice(pathIndex);
+          if (shouldDecodeParam) {
+            param2 = safeDecodeURIComponent(param2);
+          }
+          params.push(param2);
+          pathIndex = pathLen;
+          break;
+        }
+        let paramEndIndex = originPath.indexOf("/", pathIndex);
+        if (paramEndIndex === -1) {
+          paramEndIndex = pathLen;
+        }
+        let param = originPath.slice(pathIndex, paramEndIndex);
+        if (shouldDecodeParam) {
+          param = safeDecodeURIComponent(param);
+        }
+        if (currentNode.regex !== undefined) {
+          const matchedParameters = currentNode.regex.exec(param);
+          if (matchedParameters === null) {
+            if (brothersNodesStack.length === 0) {
+              return;
+            }
+            const brotherNodeState = brothersNodesStack.pop();
+            pathIndex = brotherNodeState.brotherPathIndex;
+            params.splice(brotherNodeState.paramsCount);
+            currentNode = brotherNodeState.brotherNode;
+            continue;
+          }
+          let maxParamLengthExceeded = false;
+          for (let i = 1;i < matchedParameters.length; i++) {
+            const matchedParam = matchedParameters[i] ?? "";
+            if (matchedParam.length > maxParamLength) {
+              maxParamLengthExceeded = true;
+              break;
+            }
+          }
+          if (maxParamLengthExceeded) {
+            if (brothersNodesStack.length === 0) {
+              return;
+            }
+            const brotherNodeState = brothersNodesStack.pop();
+            pathIndex = brotherNodeState.brotherPathIndex;
+            params.splice(brotherNodeState.paramsCount);
+            currentNode = brotherNodeState.brotherNode;
+            continue;
+          }
+          for (let i = 1;i < matchedParameters.length; i++) {
+            params.push(matchedParameters[i] ?? "");
+          }
+        } else {
+          if (param.length > maxParamLength) {
+            if (brothersNodesStack.length === 0) {
+              return;
+            }
+            const brotherNodeState = brothersNodesStack.pop();
+            pathIndex = brotherNodeState.brotherPathIndex;
+            params.splice(brotherNodeState.paramsCount);
+            currentNode = brotherNodeState.brotherNode;
+            continue;
+          }
+          params.push(param);
+        }
+        pathIndex = paramEndIndex;
+        break;
+      }
+    }
+  }
 }
 
-class SocketOpenError extends (/* @__PURE__ */ Error4("effect/socket/Socket/SocketOpenError")({
-  _tag: /* @__PURE__ */ tag("SocketOpenError"),
-  kind: /* @__PURE__ */ Literals(["Unknown", "Timeout"]),
-  cause: /* @__PURE__ */ Defect()
-})) {
-  get message() {
-    return this.kind === "Timeout" ? `timeout waiting for "open"` : `An error occurred during Open`;
+class HandlerStorage {
+  handlers = [];
+  unconstrainedHandler;
+  find() {
+    return this.unconstrainedHandler;
+  }
+  add(route) {
+    const handler = {
+      params: route.params,
+      handler: route.handler,
+      createParams: makeCreateParams(route.params)
+    };
+    this.handlers.push(handler);
+    this.unconstrainedHandler = this.handlers[0];
   }
 }
 
-class SocketUpgradeError extends (/* @__PURE__ */ Error4("effect/socket/Socket/SocketUpgradeError")({
-  _tag: /* @__PURE__ */ tag("SocketUpgradeError"),
-  cause: /* @__PURE__ */ optional2(/* @__PURE__ */ Defect())
-})) {
-  static unsupported = () => fail6(new SocketError({
-    reason: new SocketUpgradeError({})
-  }));
-  get message() {
-    return this.cause === undefined ? `Socket does not support TLS upgrade` : `An error occurred during TLS upgrade`;
+class NodeBase {
+  isLeafNode = false;
+  routes;
+  handlerStorage;
+  addRoute(route) {
+    if (this.routes === undefined) {
+      this.routes = [route];
+    } else {
+      this.routes.push(route);
+    }
+    if (this.handlerStorage === undefined) {
+      this.handlerStorage = new HandlerStorage;
+    }
+    this.isLeafNode = true;
+    this.handlerStorage.add(route);
   }
 }
 
-class SocketCloseError extends (/* @__PURE__ */ Error4("effect/socket/Socket/SocketCloseError")({
-  _tag: /* @__PURE__ */ tag("SocketCloseError"),
-  code: Int,
-  closeReason: /* @__PURE__ */ optional2(String7)
-})) {
-  get message() {
-    if (this.closeReason) {
-      return `${this.code}: ${this.closeReason}`;
+class ParentNode extends NodeBase {
+  staticChildren = /* @__PURE__ */ Object.create(null);
+  findStaticMatchingChild(path, pathIndex) {
+    const staticChild = this.staticChildren[path.charAt(pathIndex)];
+    if (staticChild === undefined || !staticChild.matchPrefix(path, pathIndex)) {
+      return;
     }
-    return `${this.code}`;
+    return staticChild;
+  }
+  getStaticChild(path, pathIndex = 0) {
+    if (path.length === pathIndex) {
+      return this;
+    }
+    const staticChild = this.findStaticMatchingChild(path, pathIndex);
+    if (staticChild === undefined) {
+      return;
+    }
+    return staticChild.getStaticChild(path, pathIndex + staticChild.prefix.length);
+  }
+  createStaticChild(path) {
+    if (path.length === 0) {
+      return this;
+    }
+    let staticChild = this.staticChildren[path.charAt(0)];
+    if (staticChild) {
+      let i = 1;
+      for (;i < staticChild.prefix.length; i++) {
+        if (path.charCodeAt(i) !== staticChild.prefix.charCodeAt(i)) {
+          staticChild = staticChild.split(this, i);
+          break;
+        }
+      }
+      return staticChild.createStaticChild(path.slice(i));
+    }
+    const label = path.charAt(0);
+    this.staticChildren[label] = new StaticNode(path);
+    return this.staticChildren[label];
   }
 }
-var SocketErrorReason = /* @__PURE__ */ Union2([SocketReadError, SocketWriteError, SocketOpenError, SocketUpgradeError, SocketCloseError]);
 
-class SocketError extends (/* @__PURE__ */ TaggedError3(SocketErrorTypeId)("SocketError", {
-  _tag: /* @__PURE__ */ tag("SocketError"),
-  reason: SocketErrorReason
-})) {
-  constructor(props) {
-    if ("cause" in props.reason) {
-      super({
-        ...props,
-        cause: props.reason.cause
-      });
+class StaticNode extends ParentNode {
+  _tag = "StaticNode";
+  constructor(prefix3) {
+    super();
+    this.setPrefix(prefix3);
+  }
+  prefix;
+  matchPrefix;
+  parametricChildren = [];
+  wildcardChild;
+  setPrefix(prefix3) {
+    this.prefix = prefix3;
+    if (prefix3.length === 1) {
+      this.matchPrefix = (_path, _pathIndex) => true;
     } else {
-      super(props);
+      const tail2 = prefix3.slice(1);
+      this.matchPrefix = (path, pathIndex) => path.startsWith(tail2, pathIndex + 1);
     }
   }
-  [SocketErrorTypeId] = SocketErrorTypeId;
-  static is(u) {
-    return isSocketError(u);
+  getParametricChild(regex) {
+    if (regex === undefined) {
+      return this.parametricChildren.find((child) => child.isRegex === false);
+    }
+    const source = regex.source;
+    return this.parametricChildren.find((child) => {
+      if (child.regex === undefined) {
+        return false;
+      }
+      return child.regex.source === source;
+    });
   }
-  message = this.reason.message;
-}
-var writeChunk = (writer, chunk) => {
-  for (let i = 0;i < chunk.length; i++) {
-    if (isCloseEvent(chunk[i])) {
-      return gen4(function* () {
-        for (let index2 = 0;index2 <= i; index2++) {
-          yield* writer.write(chunk[index2]);
-        }
+  createParametricChild(regex, staticSuffix, nodePath) {
+    let child = this.getParametricChild(regex);
+    if (child !== undefined) {
+      child.nodePaths.add(nodePath);
+      return child;
+    }
+    child = new ParametricNode(regex, staticSuffix, nodePath);
+    this.parametricChildren.push(child);
+    this.parametricChildren.sort((child1, child2) => {
+      if (!child1.isRegex)
+        return 1;
+      if (!child2.isRegex)
+        return -1;
+      if (child1.staticSuffix === undefined)
+        return 1;
+      if (child2.staticSuffix === undefined)
+        return -1;
+      if (child2.staticSuffix.endsWith(child1.staticSuffix))
+        return 1;
+      if (child1.staticSuffix.endsWith(child2.staticSuffix))
+        return -1;
+      return 0;
+    });
+    return child;
+  }
+  createWildcardChild() {
+    if (this.wildcardChild === undefined) {
+      this.wildcardChild = new WildcardNode;
+    }
+    return this.wildcardChild;
+  }
+  split(parentNode, length2) {
+    const parentPrefix = this.prefix.slice(0, length2);
+    const childPrefix = this.prefix.slice(length2);
+    this.setPrefix(childPrefix);
+    const staticNode = new StaticNode(parentPrefix);
+    staticNode.staticChildren[childPrefix.charAt(0)] = this;
+    parentNode.staticChildren[parentPrefix.charAt(0)] = staticNode;
+    return staticNode;
+  }
+  getNextNode(path, pathIndex, nodeStack, paramsCount) {
+    let node = this.findStaticMatchingChild(path, pathIndex);
+    let parametricBrotherNodeIndex = 0;
+    if (node === undefined) {
+      if (this.parametricChildren.length === 0) {
+        return this.wildcardChild;
+      }
+      node = this.parametricChildren[0];
+      parametricBrotherNodeIndex = 1;
+    }
+    if (this.wildcardChild !== undefined) {
+      nodeStack.push({
+        paramsCount,
+        brotherPathIndex: pathIndex,
+        brotherNode: this.wildcardChild
       });
     }
+    for (let i = this.parametricChildren.length - 1;i >= parametricBrotherNodeIndex; i--) {
+      nodeStack.push({
+        paramsCount,
+        brotherPathIndex: pathIndex,
+        brotherNode: this.parametricChildren[i]
+      });
+    }
+    return node;
+  }
+}
+
+class ParametricNode extends ParentNode {
+  _tag = "ParametricNode";
+  regex;
+  staticSuffix;
+  constructor(regex, staticSuffix, nodePath) {
+    super();
+    this.regex = regex;
+    this.staticSuffix = staticSuffix;
+    this.isRegex = !!regex;
+    this.nodePaths = new Set([nodePath]);
+  }
+  isRegex;
+  nodePaths;
+  getNextNode(path, pathIndex) {
+    return this.findStaticMatchingChild(path, pathIndex);
+  }
+}
+
+class WildcardNode extends NodeBase {
+  _tag = "WildcardNode";
+  getNextNode(_path, _pathIndex, _nodeStack, _paramsCount) {
+    return;
+  }
+}
+var assert2 = (condition, message) => {
+  if (!condition) {
+    throw new Error(message);
   }
-  return writer.writeAll(chunk);
 };
-var toChannelWithReader = (self, reader) => fromTransform(fnUntraced2(function* (upstream, scope3) {
-  const readScope = yield* fork(scope3);
-  const pull = yield* provide(reader, readScope);
-  const writeScope = yield* fork(scope3);
-  const writer = yield* provide(self.writer, writeScope);
-  let writeFailure;
-  yield* upstream.pipe(flatMap6((chunk) => writeChunk(writer, chunk)), forever4({
-    disableYield: true
-  }), catchCauseFilter2(filterNoDone, (cause) => suspend3(() => {
-    writeFailure = cause;
-    return close(readScope, void_4);
-  })), ensuring2(close(writeScope, void_4)), forkIn2(scope3));
-  return catchCause3(suspend3(() => writeFailure !== undefined ? failCause4(writeFailure) : pull), (cause) => failCause4(writeFailure ?? cause));
-}));
-var toChannel3 = (self) => toChannelWithReader(self, readerBytes(self));
-var toChannelWith = () => (self) => toChannel3(self);
-var defaultHighWaterMark = 64 * 1024;
+function removeDuplicateSlashes(path) {
+  if (path.indexOf("//") === -1) {
+    return path;
+  }
+  return path.replace(/\/\/+/g, "/");
+}
+function trimLastSlash(path) {
+  if (path.length > 1 && path.charCodeAt(path.length - 1) === 47) {
+    return path.slice(0, -1);
+  }
+  return path;
+}
+function makeCreateParams(params) {
+  const len = params.length;
+  if (len === 0) {
+    return () => Object.create(null);
+  }
+  return function(paramsArray) {
+    const paramsObject = Object.create(null);
+    for (let i = 0;i < len; i++) {
+      paramsObject[params[i]] = paramsArray[i];
+    }
+    return paramsObject;
+  };
+}
+function getClosingParenthensePosition(path, idx) {
+  let parentheses = 1;
+  while (idx < path.length) {
+    idx++;
+    if (path[idx] === "\\") {
+      idx++;
+      continue;
+    }
+    if (path[idx] === ")") {
+      parentheses--;
+    } else if (path[idx] === "(") {
+      parentheses++;
+    }
+    if (!parentheses)
+      return idx;
+  }
+  throw new TypeError('Invalid regexp expression in "' + path + '"');
+}
+function trimRegExpStartAndEnd(regexString) {
+  if (regexString.charCodeAt(1) === 94) {
+    regexString = regexString.slice(0, 1) + regexString.slice(2);
+  }
+  if (regexString.charCodeAt(regexString.length - 2) === 36) {
+    regexString = regexString.slice(0, regexString.length - 2) + regexString.slice(regexString.length - 1);
+  }
+  return regexString;
+}
+function escapeRegExp(string4) {
+  return string4.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function decodeComponentChar(highCharCode, lowCharCode) {
+  if (highCharCode === 50) {
+    if (lowCharCode === 53)
+      return "%";
+    if (lowCharCode === 51)
+      return "#";
+    if (lowCharCode === 52)
+      return "$";
+    if (lowCharCode === 54)
+      return "&";
+    if (lowCharCode === 66)
+      return "+";
+    if (lowCharCode === 98)
+      return "+";
+    if (lowCharCode === 67)
+      return ",";
+    if (lowCharCode === 99)
+      return ",";
+    if (lowCharCode === 70)
+      return "/";
+    if (lowCharCode === 102)
+      return "/";
+    return;
+  }
+  if (highCharCode === 51) {
+    if (lowCharCode === 65)
+      return ":";
+    if (lowCharCode === 97)
+      return ":";
+    if (lowCharCode === 66)
+      return ";";
+    if (lowCharCode === 98)
+      return ";";
+    if (lowCharCode === 68)
+      return "=";
+    if (lowCharCode === 100)
+      return "=";
+    if (lowCharCode === 70)
+      return "?";
+    if (lowCharCode === 102)
+      return "?";
+    return;
+  }
+  if (highCharCode === 52 && lowCharCode === 48) {
+    return "@";
+  }
+  return;
+}
+function safeDecodeURI(path) {
+  let shouldDecode = false;
+  let shouldDecodeParam = false;
+  let querystring = "";
+  for (let i = 1;i < path.length; i++) {
+    const charCode = path.charCodeAt(i);
+    if (charCode === 37) {
+      const highCharCode = path.charCodeAt(i + 1);
+      const lowCharCode = path.charCodeAt(i + 2);
+      if (decodeComponentChar(highCharCode, lowCharCode) === undefined) {
+        shouldDecode = true;
+      } else {
+        shouldDecodeParam = true;
+        if (highCharCode === 50 && lowCharCode === 53) {
+          shouldDecode = true;
+          path = path.slice(0, i + 1) + "25" + path.slice(i + 1);
+          i += 2;
+        }
+        i += 2;
+      }
+    } else if (charCode === 63 || charCode === 59 || charCode === 35) {
+      querystring = path.slice(i + 1);
+      path = path.slice(0, i);
+      break;
+    }
+  }
+  const decodedPath = shouldDecode ? decodeURI(path) : path;
+  return {
+    path: decodedPath,
+    querystring,
+    shouldDecodeParam
+  };
+}
+function safeDecodeURIComponent(uriComponent) {
+  const startIndex = uriComponent.indexOf("%");
+  if (startIndex === -1)
+    return uriComponent;
+  let decoded = "";
+  let lastIndex = startIndex;
+  for (let i = startIndex;i < uriComponent.length; i++) {
+    if (uriComponent.charCodeAt(i) === 37) {
+      if (i + 2 >= uriComponent.length)
+        break;
+      const highCharCode = uriComponent.charCodeAt(i + 1);
+      const lowCharCode = uriComponent.charCodeAt(i + 2);
+      const decodedChar = decodeComponentChar(highCharCode, lowCharCode);
+      decoded += uriComponent.slice(lastIndex, i) + decodedChar;
+      lastIndex = i + 3;
+    }
+  }
+  return uriComponent.slice(0, startIndex) + decoded + uriComponent.slice(lastIndex);
+}
+var httpMethods = ["ACL", "BIND", "CHECKOUT", "CONNECT", "COPY", "DELETE", "GET", "HEAD", "LINK", "LOCK", "M-SEARCH", "MERGE", "MKACTIVITY", "MKCALENDAR", "MKCOL", "MOVE", "NOTIFY", "OPTIONS", "PATCH", "POST", "PROPFIND", "PROPPATCH", "PURGE", "PUT", "QUERY", "REBIND", "REPORT", "SEARCH", "SOURCE", "SUBSCRIBE", "TRACE", "UNBIND", "UNLINK", "UNLOCK", "UNSUBSCRIBE"];
 
-// ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/ErrorReporter.js
-var ignore5 = "~effect/ErrorReporter/ignore";
+// ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/http/FindMyWay.js
+var make54 = make53;
 
 // ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/http/HttpServerResponse.js
 var exports_HttpServerResponse = {};
@@ -36101,12 +36901,15 @@ __export(exports_HttpServerResponse, {
   empty: () => empty17
 });
 
+// ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/ErrorReporter.js
+var ignore5 = "~effect/ErrorReporter/ignore";
+
 // ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/http/internal/headers.js
 var Proto14 = /* @__PURE__ */ Object.getPrototypeOf(empty13);
 var emptyMutableUnsafe = () => Object.create(Proto14);
 
 // ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/http/Template.js
-function make53(strings, ...args2) {
+function make55(strings, ...args2) {
   const argsLength = args2.length;
   const values4 = new Array(argsLength);
   const effects = [];
@@ -36252,7 +37055,7 @@ var html = (strings, ...args2) => {
       contentType: "text/html"
     });
   }
-  return map9(make53(strings, ...args2), (_) => text2(_, {
+  return map9(make55(strings, ...args2), (_) => text2(_, {
     contentType: "text/html"
   }));
 };
@@ -36502,7 +37305,7 @@ class ServerHttpClientResponse extends Class2 {
   get url() {
     if (this.request === empty16)
       return "";
-    const url = toUrl(this.request);
+    const url = toUrl2(this.request);
     if (isNone2(url))
       return "";
     url.value.hash = "";
@@ -36726,8 +37529,45 @@ var fromWeb3 = (response) => {
   return self;
 };
 
+// ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/http/internal/compression.js
+var varyWith = (headers, dimension) => {
+  const vary = headers["vary"];
+  if (vary === undefined) {
+    return dimension;
+  }
+  const members = vary.split(",").map((member) => member.trim().toLowerCase());
+  return members.includes("*") || members.includes(dimension.toLowerCase()) ? vary : `${vary}, ${dimension}`;
+};
+
 // ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/http/HttpServerRespondable.js
 var symbol5 = "~effect/http/HttpServerRespondable";
+var isRespondable = (u) => hasProperty(u, symbol5);
+var badRequest = /* @__PURE__ */ empty17({
+  status: 400
+});
+var notFound3 = /* @__PURE__ */ empty17({
+  status: 404
+});
+var toResponseOrElse = (u, orElse6) => {
+  if (isHttpServerResponse(u)) {
+    return succeed6(u);
+  } else if (isRespondable(u)) {
+    return catchCause3(u[symbol5](), () => succeed6(orElse6));
+  } else if (isSchemaError(u)) {
+    return succeed6(badRequest);
+  } else if (isNoSuchElementError2(u)) {
+    return succeed6(notFound3);
+  }
+  return succeed6(orElse6);
+};
+var toResponseOrElseDefect = (u, orElse6) => {
+  if (isHttpServerResponse(u)) {
+    return succeed6(u);
+  } else if (isRespondable(u)) {
+    return catchCause3(u[symbol5](), () => succeed6(orElse6));
+  }
+  return succeed6(orElse6);
+};
 
 // ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/http/HttpServerError.js
 var TypeId58 = "~effect/http/HttpServerError";
@@ -36775,10 +37615,257 @@ class RequestParseError extends (/* @__PURE__ */ TaggedError2("RequestParseError
     return formatRequestMessage(this._tag, this.description, this.methodAndUrl);
   }
 }
+
+class RouteNotFound extends (/* @__PURE__ */ TaggedError2("RouteNotFound")) {
+  [symbol5]() {
+    return succeed6(empty17({
+      status: 404
+    }));
+  }
+  [ignore5] = true;
+  get methodAndUrl() {
+    return `${this.request.method} ${this.request.url}`;
+  }
+  get message() {
+    return formatRequestMessage(this._tag, this.description, this.methodAndUrl);
+  }
+}
+class ResponseError extends (/* @__PURE__ */ TaggedError2("ResponseError")) {
+  [symbol5]() {
+    return succeed6(empty17({
+      status: 500
+    }));
+  }
+  get methodAndUrl() {
+    return `${this.request.method} ${this.request.url}`;
+  }
+  get message() {
+    const info2 = `${this._tag} (${this.response.status} ${this.methodAndUrl})`;
+    return this.description ? `${info2}: ${this.description}` : info2;
+  }
+}
+class ClientAbort extends (/* @__PURE__ */ Service()("effect/http/HttpServerError/ClientAbort")) {
+  static annotation = /* @__PURE__ */ this.context(true).pipe(/* @__PURE__ */ add(StackTrace, {
+    name: "ClientAbort",
+    stack: constUndefined,
+    parent: undefined
+  }));
+}
 var formatRequestMessage = (reason, description, info2) => {
   const prefix3 = `${reason} (${info2})`;
   return description ? `${prefix3}: ${description}` : prefix3;
 };
+var causeResponse = (cause) => {
+  let response;
+  let effect2 = succeedInternalServerError;
+  const failures = [];
+  let interrupts = [];
+  let isClientInterrupt = false;
+  for (let i = 0;i < cause.reasons.length; i++) {
+    const reason = cause.reasons[i];
+    switch (reason._tag) {
+      case "Fail": {
+        effect2 = toResponseOrElse(reason.error, internalServerError);
+        failures.push(reason);
+        break;
+      }
+      case "Die": {
+        if (isHttpServerResponse(reason.defect)) {
+          response = reason.defect;
+        } else {
+          effect2 = toResponseOrElseDefect(reason.defect, internalServerError);
+          failures.push(reason);
+        }
+        break;
+      }
+      case "Interrupt": {
+        isClientInterrupt = reason.annotations.has(ClientAbort.key);
+        if (failures.length > 0)
+          break;
+        interrupts.push(reason);
+        break;
+      }
+    }
+  }
+  if (response) {
+    return succeed6([response, fromReasons(failures)]);
+  } else if (interrupts.length > 0 && failures.length === 0) {
+    failures.push(...interrupts);
+    effect2 = isClientInterrupt ? clientAbortError : serverAbortError;
+  }
+  return mapEager2(effect2, (response2) => {
+    failures.push(makeDieReason(response2));
+    return [response2, fromReasons(failures)];
+  });
+};
+var causeResponseStripped = (cause) => {
+  let response;
+  const failures = cause.reasons.filter((f) => {
+    if (f._tag === "Die" && isHttpServerResponse(f.defect)) {
+      response = f.defect;
+      return false;
+    }
+    return true;
+  });
+  return [response ?? internalServerError, failures.length > 0 ? some3(fromReasons(failures)) : none2()];
+};
+var internalServerError = /* @__PURE__ */ empty17({
+  status: 500
+});
+var succeedInternalServerError = /* @__PURE__ */ succeed6(internalServerError);
+var clientAbortError = /* @__PURE__ */ succeed6(/* @__PURE__ */ empty17({
+  status: 499
+}));
+var serverAbortError = /* @__PURE__ */ succeed6(/* @__PURE__ */ empty17({
+  status: 503
+}));
+
+// ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/http/HttpServerRequest.js
+var exports_HttpServerRequest = {};
+__export(exports_HttpServerRequest, {
+  upgradeChannel: () => upgradeChannel,
+  toWebResult: () => toWebResult2,
+  toWeb: () => toWeb3,
+  toURL: () => toURL,
+  toClientRequest: () => toClientRequest,
+  searchParamsFromURL: () => searchParamsFromURL,
+  schemaSearchParams: () => schemaSearchParams,
+  schemaHeaders: () => schemaHeaders,
+  schemaCookies: () => schemaCookies,
+  schemaBodyUrlParams: () => schemaBodyUrlParams2,
+  schemaBodyMultipart: () => schemaBodyMultipart,
+  schemaBodyJson: () => schemaBodyJson3,
+  schemaBodyFormJson: () => schemaBodyFormJson,
+  schemaBodyForm: () => schemaBodyForm,
+  fromWeb: () => fromWeb4,
+  fromClientRequest: () => fromClientRequest,
+  TypeId: () => TypeId60,
+  ParsedSearchParams: () => ParsedSearchParams,
+  MaxBodySize: () => MaxBodySize,
+  HttpServerRequest: () => HttpServerRequest
+});
+
+// ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/socket/Socket.js
+var encoder5 = /* @__PURE__ */ new TextEncoder;
+var readerBytes = (self) => map9(self.reader, ({
+  pull
+}) => map9(pull, (chunk) => {
+  for (let i = 0;i < chunk.length; i++) {
+    if (typeof chunk[i] === "string") {
+      const out = new Array(chunk.length);
+      for (let j = 0;j < chunk.length; j++) {
+        const item = chunk[j];
+        out[j] = typeof item === "string" ? encoder5.encode(item) : item;
+      }
+      return out;
+    }
+  }
+  return chunk;
+}));
+var CloseEventTypeId = "~effect/socket/Socket/CloseEvent";
+var isCloseEvent = (u) => hasProperty(u, CloseEventTypeId);
+var SocketErrorTypeId = "~effect/socket/Socket/SocketError";
+var isSocketError = (u) => hasProperty(u, SocketErrorTypeId);
+
+class SocketReadError extends (/* @__PURE__ */ Error4("effect/socket/Socket/SocketReadError")({
+  _tag: /* @__PURE__ */ tag("SocketReadError"),
+  cause: /* @__PURE__ */ Defect()
+})) {
+  message = `An error occurred during Read`;
+}
+
+class SocketWriteError extends (/* @__PURE__ */ Error4("effect/socket/Socket/SocketWriteError")({
+  _tag: /* @__PURE__ */ tag("SocketWriteError"),
+  cause: /* @__PURE__ */ Defect()
+})) {
+  message = `An error occurred during Write`;
+}
+
+class SocketOpenError extends (/* @__PURE__ */ Error4("effect/socket/Socket/SocketOpenError")({
+  _tag: /* @__PURE__ */ tag("SocketOpenError"),
+  kind: /* @__PURE__ */ Literals(["Unknown", "Timeout"]),
+  cause: /* @__PURE__ */ Defect()
+})) {
+  get message() {
+    return this.kind === "Timeout" ? `timeout waiting for "open"` : `An error occurred during Open`;
+  }
+}
+
+class SocketUpgradeError extends (/* @__PURE__ */ Error4("effect/socket/Socket/SocketUpgradeError")({
+  _tag: /* @__PURE__ */ tag("SocketUpgradeError"),
+  cause: /* @__PURE__ */ optional2(/* @__PURE__ */ Defect())
+})) {
+  static unsupported = () => fail6(new SocketError({
+    reason: new SocketUpgradeError({})
+  }));
+  get message() {
+    return this.cause === undefined ? `Socket does not support TLS upgrade` : `An error occurred during TLS upgrade`;
+  }
+}
+
+class SocketCloseError extends (/* @__PURE__ */ Error4("effect/socket/Socket/SocketCloseError")({
+  _tag: /* @__PURE__ */ tag("SocketCloseError"),
+  code: Int,
+  closeReason: /* @__PURE__ */ optional2(String7)
+})) {
+  get message() {
+    if (this.closeReason) {
+      return `${this.code}: ${this.closeReason}`;
+    }
+    return `${this.code}`;
+  }
+}
+var SocketErrorReason = /* @__PURE__ */ Union2([SocketReadError, SocketWriteError, SocketOpenError, SocketUpgradeError, SocketCloseError]);
+
+class SocketError extends (/* @__PURE__ */ TaggedError3(SocketErrorTypeId)("SocketError", {
+  _tag: /* @__PURE__ */ tag("SocketError"),
+  reason: SocketErrorReason
+})) {
+  constructor(props) {
+    if ("cause" in props.reason) {
+      super({
+        ...props,
+        cause: props.reason.cause
+      });
+    } else {
+      super(props);
+    }
+  }
+  [SocketErrorTypeId] = SocketErrorTypeId;
+  static is(u) {
+    return isSocketError(u);
+  }
+  message = this.reason.message;
+}
+var writeChunk = (writer, chunk) => {
+  for (let i = 0;i < chunk.length; i++) {
+    if (isCloseEvent(chunk[i])) {
+      return gen4(function* () {
+        for (let index2 = 0;index2 <= i; index2++) {
+          yield* writer.write(chunk[index2]);
+        }
+      });
+    }
+  }
+  return writer.writeAll(chunk);
+};
+var toChannelWithReader = (self, reader) => fromTransform(fnUntraced2(function* (upstream, scope3) {
+  const readScope = yield* fork(scope3);
+  const pull = yield* provide(reader, readScope);
+  const writeScope = yield* fork(scope3);
+  const writer = yield* provide(self.writer, writeScope);
+  let writeFailure;
+  yield* upstream.pipe(flatMap6((chunk) => writeChunk(writer, chunk)), forever4({
+    disableYield: true
+  }), catchCauseFilter2(filterNoDone, (cause) => suspend3(() => {
+    writeFailure = cause;
+    return close(readScope, void_4);
+  })), ensuring2(close(writeScope, void_4)), forkIn2(scope3));
+  return catchCause3(suspend3(() => writeFailure !== undefined ? failCause4(writeFailure) : pull), (cause) => failCause4(writeFailure ?? cause));
+}));
+var toChannel3 = (self) => toChannelWithReader(self, readerBytes(self));
+var toChannelWith = () => (self) => toChannel3(self);
+var defaultHighWaterMark = 64 * 1024;
 
 // ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/http/MultipartParser/internal/contentType.js
 var paramRE = /; *([!#$%&'*+.^\w`|~-]+)=("(?:[\v\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u{10ffff}]|\\[\v\u0020-\u{10ffff}])*"|[!#$%&'*+.^\w`|~-]+) */gu;
@@ -36789,7 +37876,7 @@ var defaultContentType = {
   value: "",
   parameters: /* @__PURE__ */ Object.create(null)
 };
-function parse2(header, withoutSlash = false) {
+function parse3(header, withoutSlash = false) {
   if (typeof header !== "string") {
     return defaultContentType;
   }
@@ -36854,7 +37941,7 @@ for (let i = 32;i <= 126; i++) {
 for (let i = 128;i <= 255; i++) {
   constValueChars[i] = 1;
 }
-function make54() {
+function make56() {
   const decoder4 = new TextDecoder;
   const state = {
     state: State.key,
@@ -37057,7 +38144,7 @@ function makeState(needle_) {
     matchIndex: 0
   };
 }
-function make55(needle, callback4, seed, minimumChunkLength) {
+function make57(needle, callback4, seed, minimumChunkLength) {
   const state = makeState(needle);
   const minChunkLength = minimumChunkLength ?? state.needleLength;
   if (seed !== undefined) {
@@ -37191,12 +38278,12 @@ function defaultIsFile(info2) {
   return info2.filename !== undefined || info2.contentType === "application/octet-stream";
 }
 function parseBoundary(headers) {
-  const contentType = parse2(headers["content-type"]);
+  const contentType = parse3(headers["content-type"]);
   return contentType.parameters.boundary;
 }
 function noopOnChunk(_chunk) {}
 var toLimit = (input) => input === Infinity ? Infinity : Number(fromInputUnsafe2(input));
-function make56({
+function make58({
   headers,
   onFile: onPart,
   onField,
@@ -37248,8 +38335,8 @@ function make56({
     }
     onError5(error2);
   }
-  const headerParser = make54();
-  const split4 = make55(`\r
+  const headerParser = make56();
+  const split4 = make57(`\r
 --${boundary}`, function(index2, chunk) {
     if (state.stopped) {
       return;
@@ -37306,8 +38393,8 @@ function make56({
           error: result6
         });
       }
-      const contentType = parse2(result6.headers["content-type"]);
-      const contentDisposition = parse2(result6.headers["content-disposition"], true);
+      const contentType = parse3(result6.headers["content-type"]);
+      const contentDisposition = parse3(result6.headers["content-disposition"], true);
       if (contentDisposition.value === "form-data" && !("name" in contentDisposition.parameters)) {
         skipBody();
         return onError5(errInvalidDisposition);
@@ -37402,7 +38489,7 @@ function decodeField(info2, value5) {
 }
 
 // ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/http/MultipartParser.js
-var make57 = make56;
+var make59 = make58;
 var defaultIsFile2 = defaultIsFile;
 var decodeField2 = decodeField;
 
@@ -37465,7 +38552,7 @@ var makeChannel = (headers) => fromTransform((upstream) => map9(makeConfig(heade
   let partsBuffer = [];
   let exit3 = none2();
   let ended = false;
-  const parser = make57({
+  const parser = make59({
     ...config,
     onField(info2, value5) {
       partsBuffer.push(new FieldImpl(info2.name, info2.contentType, decodeField2(info2, value5)));
@@ -37716,20 +38803,20 @@ var searchParamsFromURL = (url) => {
 };
 var upgradeChannel = () => HttpServerRequest.pipe(flatMap6((_) => _.upgrade), map9(toChannelWith()), unwrap2);
 var schemaCookies = (schema2, options3) => {
-  const parse3 = decodeUnknownEffect2(schema2);
-  return flatMap6(HttpServerRequest, (req) => parse3(req.cookies, options3));
+  const parse4 = decodeUnknownEffect2(schema2);
+  return flatMap6(HttpServerRequest, (req) => parse4(req.cookies, options3));
 };
 var schemaHeaders = (schema2, options3) => {
-  const parse3 = decodeUnknownEffect2(schema2);
-  return flatMap6(HttpServerRequest, (req) => parse3(req.headers, options3));
+  const parse4 = decodeUnknownEffect2(schema2);
+  return flatMap6(HttpServerRequest, (req) => parse4(req.headers, options3));
 };
 var schemaSearchParams = (schema2, options3) => {
-  const parse3 = decodeUnknownEffect2(schema2);
-  return flatMap6(ParsedSearchParams, (params) => parse3(params, options3));
+  const parse4 = decodeUnknownEffect2(schema2);
+  return flatMap6(ParsedSearchParams, (params) => parse4(params, options3));
 };
 var schemaBodyJson3 = (schema2, options3) => {
-  const parse3 = schemaBodyJson2(schema2, options3);
-  return flatMap6(HttpServerRequest, parse3);
+  const parse4 = schemaBodyJson2(schema2, options3);
+  return flatMap6(HttpServerRequest, parse4);
 };
 var isMultipart = (request3) => request3.headers["content-type"]?.toLowerCase().includes("multipart/form-data") === true || getFormDataBody(request3) !== undefined;
 var schemaBodyForm = (schema2, options3) => {
@@ -37743,12 +38830,12 @@ var schemaBodyForm = (schema2, options3) => {
   });
 };
 var schemaBodyUrlParams2 = (schema2, options3) => {
-  const parse3 = schemaBodyUrlParams(schema2, options3);
-  return flatMap6(HttpServerRequest, parse3);
+  const parse4 = schemaBodyUrlParams(schema2, options3);
+  return flatMap6(HttpServerRequest, parse4);
 };
 var schemaBodyMultipart = (schema2, options3) => {
-  const parse3 = schemaPersisted(schema2);
-  return HttpServerRequest.pipe(flatMap6((_) => _.multipart), flatMap6((_) => parse3(_, options3)));
+  const parse4 = schemaPersisted(schema2);
+  return HttpServerRequest.pipe(flatMap6((_) => _.multipart), flatMap6((_) => parse4(_, options3)));
 };
 var schemaBodyFormJson = (schema2, options3) => {
   const parseMultipart = schemaJson2(schema2, options3);
@@ -37768,7 +38855,7 @@ var schemaBodyFormJson = (schema2, options3) => {
   };
 };
 var fromClientRequest = (request3) => {
-  const url = match(toUrl(request3), {
+  const url = match(toUrl2(request3), {
     onNone: () => request3.url,
     onSome: (url2) => url2.toString()
   });
@@ -38229,6 +39316,743 @@ var toWeb3 = (self, options3) => contextWith2((context3) => fromResult2(toWebRes
   context: context3,
   signal: options3?.signal
 })));
+
+// ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/http/internal/preResponseHandler.js
+var requestPreResponseHandlers = /* @__PURE__ */ new WeakMap;
+var appendPreResponseHandlerUnsafe = (request3, handler) => {
+  const prev = requestPreResponseHandlers.get(request3.source);
+  const next3 = prev ? (request4, response) => flatMap6(prev(request4, response), (response2) => handler(request4, response2)) : handler;
+  requestPreResponseHandlers.set(request3.source, next3);
+};
+
+// ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/http/HttpMiddleware.js
+var make60 = (middleware) => middleware;
+var loggerDisabledRequests = /* @__PURE__ */ new WeakSet;
+var stripSearchAndHash = (url) => {
+  const queryIndex = url.indexOf("?");
+  const hashIndex = url.indexOf("#");
+  if (queryIndex === -1) {
+    return hashIndex === -1 ? url : url.slice(0, hashIndex);
+  }
+  if (hashIndex === -1) {
+    return url.slice(0, queryIndex);
+  }
+  return url.slice(0, Math.min(queryIndex, hashIndex));
+};
+var withLoggerDisabled = (self) => withFiber2((fiber3) => {
+  const request3 = getUnsafe(fiber3.context, HttpServerRequest);
+  loggerDisabledRequests.add(request3.source);
+  return self;
+});
+var TracerDisabledWhen2 = /* @__PURE__ */ Reference("effect/http/HttpMiddleware/TracerDisabledWhen", {
+  defaultValue: () => constFalse
+});
+var SpanNameGenerator2 = /* @__PURE__ */ Reference("@effect/platform/HttpMiddleware/SpanNameGenerator", {
+  defaultValue: () => (request3) => request3.method
+});
+var TracerHeaderFilter2 = /* @__PURE__ */ Reference("effect/http/HttpMiddleware/TracerHeaderFilter", {
+  defaultValue: () => constFalse
+});
+var logger = /* @__PURE__ */ make60((httpApp) => withFiber2((fiber3) => {
+  const request3 = getUnsafe(fiber3.context, HttpServerRequest);
+  const path = stripSearchAndHash(request3.url);
+  return withLogSpan(flatMap6(exit2(httpApp), (exit3) => {
+    if (loggerDisabledRequests.has(request3.source)) {
+      return exit3;
+    } else if (exit3._tag === "Failure") {
+      const [response, cause] = causeResponseStripped(exit3.cause);
+      const message = isSome2(cause) && !cause.value.reasons.every((reason) => reason._tag === "Interrupt" && reason.annotations.has(ClientAbort.key)) ? cause.value : "Sent HTTP response";
+      return andThen4(annotateLogs(log(message), {
+        "http.method": request3.method,
+        "http.url": path,
+        "http.status": response.status
+      }), exit3);
+    }
+    return andThen4(annotateLogs(log("Sent HTTP response"), {
+      "http.method": request3.method,
+      "http.url": path,
+      "http.status": exit3.value.status
+    }), exit3);
+  }), "http.span");
+}));
+var isTracerDisabledUnsafe = (fiber3, request3) => !fiber3.cache.tracerEnabled || fiber3.getRef(TracerDisabledWhen2)(request3);
+var responseSpanExit = (request3, response) => {
+  if (!(response.status >= 500 && response.status < 600)) {
+    return succeed4(response);
+  }
+  const stackTraceLimit = getStackTraceLimit();
+  setStackTraceLimit(0);
+  try {
+    return fail5(new HttpServerError({
+      reason: new ResponseError({
+        request: request3,
+        response
+      })
+    }));
+  } finally {
+    setStackTraceLimit(stackTraceLimit);
+  }
+};
+var tracer3 = /* @__PURE__ */ make60((httpApp) => withFiber2((fiber3) => {
+  const request3 = getUnsafe(fiber3.context, HttpServerRequest);
+  if (isTracerDisabledUnsafe(fiber3, request3)) {
+    return httpApp;
+  }
+  const nameGenerator = fiber3.getRef(SpanNameGenerator2);
+  const span3 = makeSpanUnsafe(fiber3, nameGenerator(request3), {
+    parent: getOrUndefined(fromHeaders(request3.headers)),
+    kind: "server"
+  });
+  const prevServices = fiber3.context;
+  fiber3.setContext(add(fiber3.context, ParentSpan, span3));
+  onExitUnsafe(fiber3, (exit3) => {
+    fiber3.setContext(prevServices);
+    const endTime = fiber3.getRef(Clock).currentTimeNanosUnsafe();
+    if (isSuccess4(exit3) && (!span3.sampled || fiber3.getRef(Tracer) === nativeTracer)) {
+      span3.end(endTime, responseSpanExit(request3, exit3.value));
+      return;
+    }
+    const redactedHeaderNames = fiber3.getRef(CurrentRedactedNames);
+    const headerFilter = fiber3.getRef(TracerHeaderFilter2);
+    fiber3.currentDispatcher.scheduleTask(() => {
+      let response;
+      let spanExit;
+      if (isFailure4(exit3)) {
+        const [failureResponse, cause] = causeResponseStripped(exit3.cause);
+        response = failureResponse;
+        spanExit = isSome2(cause) && (response.status >= 500 || hasInterrupts2(cause.value)) ? failCause2(cause.value) : responseSpanExit(request3, response);
+      } else {
+        response = exit3.value;
+        spanExit = responseSpanExit(request3, response);
+      }
+      if (span3.sampled) {
+        span3.attribute("http.request.method", request3.method);
+        const url = toURL(request3);
+        if (isSome2(url)) {
+          if (!request3.url.startsWith("/") && (url.value.username !== "" || url.value.password !== "")) {
+            url.value.username = "REDACTED";
+            url.value.password = "REDACTED";
+          }
+          addUrlAttributes(span3, url.value);
+        }
+        if (request3.headers["user-agent"] !== undefined) {
+          span3.attribute("user_agent.original", request3.headers["user-agent"]);
+        }
+        addHeaderAttributes(span3, "request", request3.headers, headerFilter, redactedHeaderNames);
+        if (isSome2(request3.remoteAddress)) {
+          span3.attribute("client.address", request3.remoteAddress.value);
+        }
+        span3.attribute("http.response.status_code", response.status);
+        addHeaderAttributes(span3, "response", response.headers, headerFilter, redactedHeaderNames);
+      }
+      span3.end(endTime, spanExit);
+    }, 0);
+    return;
+  });
+  return httpApp;
+}));
+var cors = (options3) => {
+  const opts = {
+    allowedOrigins: options3?.allowedOrigins ?? [],
+    allowedMethods: options3?.allowedMethods ?? ["GET", "HEAD", "PUT", "PATCH", "POST", "DELETE"],
+    allowedHeaders: options3?.allowedHeaders ?? [],
+    exposedHeaders: options3?.exposedHeaders ?? [],
+    credentials: options3?.credentials ?? false,
+    maxAge: options3?.maxAge
+  };
+  const isAllowedOrigin = typeof opts.allowedOrigins === "function" ? opts.allowedOrigins : (origin) => opts.allowedOrigins.includes(origin);
+  const allowOrigin = typeof opts.allowedOrigins === "function" || opts.allowedOrigins.length > 1 ? (originHeader) => {
+    if (!isAllowedOrigin(originHeader))
+      return {
+        vary: "Origin"
+      };
+    return {
+      "access-control-allow-origin": originHeader,
+      vary: "Origin"
+    };
+  } : opts.allowedOrigins.length === 0 ? constant({
+    "access-control-allow-origin": "*"
+  }) : constant({
+    "access-control-allow-origin": opts.allowedOrigins[0],
+    vary: "Origin"
+  });
+  const allowMethods = opts.allowedMethods.length > 0 ? {
+    "access-control-allow-methods": opts.allowedMethods.join(", ")
+  } : undefined;
+  const allowCredentials = opts.credentials ? {
+    "access-control-allow-credentials": "true"
+  } : undefined;
+  const allowHeaders = (accessControlRequestHeaders) => {
+    if (opts.allowedHeaders.length === 0 && accessControlRequestHeaders) {
+      return {
+        vary: "Access-Control-Request-Headers",
+        "access-control-allow-headers": accessControlRequestHeaders
+      };
+    }
+    if (opts.allowedHeaders) {
+      return {
+        "access-control-allow-headers": opts.allowedHeaders.join(",")
+      };
+    }
+    return;
+  };
+  const exposeHeaders = opts.exposedHeaders.length > 0 ? {
+    "access-control-expose-headers": opts.exposedHeaders.join(",")
+  } : undefined;
+  const maxAge = opts.maxAge ? {
+    "access-control-max-age": opts.maxAge.toString()
+  } : undefined;
+  const headersFromRequest = (request3) => {
+    const origin = request3.headers["origin"];
+    return fromRecordUnsafe({
+      ...allowOrigin(origin),
+      ...allowCredentials,
+      ...exposeHeaders
+    });
+  };
+  const headersFromRequestOptions = (request3) => {
+    const origin = request3.headers["origin"];
+    const accessControlRequestHeaders = request3.headers["access-control-request-headers"];
+    const headers = fromRecordUnsafe({
+      ...allowOrigin(origin),
+      ...allowCredentials,
+      ...exposeHeaders,
+      ...allowMethods,
+      ...maxAge
+    });
+    const accessControlHeaders = allowHeaders(accessControlRequestHeaders);
+    if (accessControlHeaders === undefined)
+      return headers;
+    const vary = accessControlHeaders["vary"];
+    return setAll2(headers, vary === undefined ? accessControlHeaders : {
+      ...accessControlHeaders,
+      vary: varyWith(headers, vary)
+    });
+  };
+  const preResponseHandler = (request3, response) => {
+    const headers = headersFromRequest(request3);
+    return succeed6(setHeaders2(response, headers["vary"] === undefined ? headers : set6(headers, "vary", varyWith(response.headers, "Origin"))));
+  };
+  return (httpApp) => withFiber2((fiber3) => {
+    const request3 = getUnsafe(fiber3.context, HttpServerRequest);
+    if (request3.method === "OPTIONS") {
+      return succeed6(empty17({
+        status: 204,
+        headers: headersFromRequestOptions(request3)
+      }));
+    }
+    appendPreResponseHandlerUnsafe(request3, preResponseHandler);
+    return httpApp;
+  });
+};
+
+// ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/http/HttpEffect.js
+var toHandled = (self, handleResponse, middleware) => {
+  const handleCause = (frame, cause) => {
+    frame.cause = cause;
+    const request3 = frame.request;
+    return flatMapEager2(causeResponse(cause), ([response, cause2]) => {
+      const fiber3 = getCurrent();
+      reportCauseUnsafe(fiber3, cause2);
+      const handler = requestPreResponseHandlers.get(request3.source);
+      const cont = cause2.reasons.length === 0 ? succeed6(response) : failCause4(cause2);
+      if (handler === undefined) {
+        request3[handledSymbol] = true;
+        return flatMapEager2(handleResponse(request3, response), () => cont);
+      }
+      return flatMapEager2(flatMapEager2(handler(request3, response), (response2) => {
+        request3[handledSymbol] = true;
+        return handleResponse(request3, response2);
+      }), () => cont);
+    });
+  };
+  const sendResponse = (request3, response) => {
+    const handler = requestPreResponseHandlers.get(request3.source);
+    if (handler === undefined) {
+      request3[handledSymbol] = true;
+      return mapEager2(handleResponse(request3, response), (sent) => isHttpServerResponse(sent) ? sent : response);
+    }
+    return flatMapEager2(handler(request3, response), (sentResponse) => {
+      request3[handledSymbol] = true;
+      return mapEager2(handleResponse(request3, sentResponse), (sent) => isHttpServerResponse(sent) ? sent : response);
+    });
+  };
+  const withMiddleware = (frame) => {
+    const request3 = frame.request;
+    const responded = matchCauseEffect2(self, {
+      onSuccess: (response) => sendResponse(request3, response),
+      onFailure: (cause) => handleCause(frame, cause)
+    });
+    return middleware === undefined ? responded : matchCauseEffect2(tracer3(middleware(responded)), {
+      onFailure(cause) {
+        reportCauseUnsafe(getCurrent(), cause);
+        if (handledSymbol in request3)
+          return void_5;
+        return matchCauseEffectEager2(causeResponse(cause), {
+          onFailure(_) {
+            return handleResponse(request3, empty17({
+              status: 500
+            }));
+          },
+          onSuccess([response]) {
+            return handleResponse(request3, response);
+          }
+        });
+      },
+      onSuccess(response) {
+        return handledSymbol in request3 ? void_5 : handleResponse(request3, response);
+      }
+    });
+  };
+  const traced = (frame) => tracer3(withMiddleware(frame));
+  const finishAfter = (frame, fiber3, effect2) => onExitPrimitive2(effect2, (exit3) => {
+    fiber3.setContext(frame.prev);
+    if (scopeEjected in frame.scope)
+      return;
+    return closeUnsafe(frame.scope, frame.cause === undefined ? exit3 : failCause2(frame.cause));
+  }, true);
+
+  class RequestFrame {
+    scope;
+    prev;
+    request;
+    cause;
+    constructor(scope3, prev, request3) {
+      this.scope = scope3;
+      this.prev = prev;
+      this.request = request3;
+    }
+    [contA](response, fiber3) {
+      const sent = sendResponse(this.request, response);
+      if (effectIsExit(sent) && sent._tag === "Success") {
+        fiber3.setContext(this.prev);
+        if (scopeEjected in this.scope)
+          return sent;
+        const closed = closeUnsafe(this.scope, sent);
+        return closed === undefined ? sent : flatMap6(closed, () => sent);
+      }
+      return finishAfter(this, fiber3, sent);
+    }
+    [contE](cause, fiber3) {
+      return finishAfter(this, fiber3, handleCause(this, cause));
+    }
+  }
+  return withFiber2((fiber3) => {
+    fiberEnterUninterruptibleUnsafe(fiber3);
+    const scope3 = makeUnsafe3();
+    const frame = new RequestFrame(scope3, fiber3.context, getUnsafe(fiber3.context, HttpServerRequest));
+    fiber3.setContext(add(frame.prev, Scope, scope3));
+    const currentTracer = fiber3.cache.tracer;
+    if (middleware === undefined && (currentTracer === undefined || currentTracer === nativeTracer || isTracerDisabledUnsafe(fiber3, frame.request))) {
+      fiber3._stack.push(frame);
+      return self;
+    }
+    return finishAfter(frame, fiber3, middleware === undefined ? traced(frame) : withMiddleware(frame));
+  });
+};
+var handledSymbol = /* @__PURE__ */ Symbol.for("effect/http/HttpEffect/handled");
+var scopeDisableClose = (scope3) => {
+  scope3[scopeEjected] = true;
+};
+var scopeTransferToStream = (response) => {
+  if (response.body._tag !== "Stream") {
+    return response;
+  }
+  const fiber3 = getCurrent();
+  const scope3 = getUnsafe(fiber3.context, Scope);
+  scopeDisableClose(scope3);
+  return setBodyKeepHeaders(response, stream(onExit4(response.body.stream, (exit3) => close(scope3, exit3)), response.body.contentType, response.body.contentLength));
+};
+var scopeEjected = /* @__PURE__ */ Symbol.for("effect/http/HttpEffect/scopeEjected");
+var toWebHandlerWith = (context3) => (self, middleware) => {
+  const resolveSymbol = Symbol.for("@effect/platform/HttpApp/resolve");
+  const httpApp = toHandled(self, (request3, response) => {
+    const withoutBody = request3.method === "HEAD";
+    if (!omitsBody(response, withoutBody)) {
+      response = scopeTransferToStream(response);
+    }
+    request3[resolveSymbol](toWeb2(response, {
+      withoutBody,
+      context: context3
+    }));
+    return void_5;
+  }, middleware);
+  return (request3, _context) => new Promise((resolve7) => {
+    let reqContext = context3;
+    if (isContext(_context)) {
+      for (const [key, value5] of _context.mapUnsafe) {
+        reqContext = addUnsafe(reqContext, key, value5);
+      }
+    }
+    const httpServerRequest = fromWeb4(request3);
+    reqContext = add(reqContext, HttpServerRequest, httpServerRequest);
+    httpServerRequest[resolveSymbol] = resolve7;
+    const fiber3 = runForkWith2(reqContext)(httpApp);
+    if (fiber3.pollUnsafe() === undefined) {
+      request3.signal?.addEventListener("abort", () => {
+        fiber3.interruptUnsafe(undefined, ClientAbort.annotation);
+      }, {
+        once: true
+      });
+    }
+  });
+};
+var toWebHandlerLayerWith = (layer15, options3) => {
+  const scope3 = makeUnsafe3();
+  const dispose = () => runPromise2(close(scope3, void_4));
+  let handlerCache;
+  const handlerPromise = runPromise2(gen4(function* () {
+    const context3 = yield* options3.memoMap ? buildWithMemoMap(layer15, options3.memoMap, scope3) : buildWithScope(layer15, scope3);
+    return handlerCache = toWebHandlerWith(context3)(yield* options3.toHandler(context3), options3.middleware);
+  }));
+  handlerPromise.catch(constVoid);
+  function handler(request3, context3) {
+    if (handlerCache) {
+      return handlerCache(request3, context3);
+    }
+    return handlerPromise.then((f) => f(request3, context3));
+  }
+  return {
+    dispose,
+    handler
+  };
+};
+
+// ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/http/HttpServer.js
+class HttpServer extends (/* @__PURE__ */ Service()("effect/http/HttpServer")) {
+}
+var serve = /* @__PURE__ */ dual((args2) => isEffect2(args2[0]), (effect2, middleware) => effectDiscard(HttpServer.use((server) => server.serve(effect2, middleware))));
+var formatAddress = formatUrlUnsafe;
+var addressFormattedWith = (f) => flatMap6(HttpServer, (server) => f(formatAddress(server.address)));
+var logAddress = /* @__PURE__ */ addressFormattedWith((_) => log(`Listening on ${_}`));
+var withLogAddress = (layer15) => effectDiscard(logAddress).pipe(provideMerge(layer15));
+
+// ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/http/HttpRouter.js
+var TypeId61 = "~effect/http/HttpRouter";
+var HttpRouter = /* @__PURE__ */ Service("effect/http/HttpRouter");
+var make61 = /* @__PURE__ */ gen4(function* () {
+  const router = make54(yield* RouterConfig);
+  const middleware = new Set;
+  const addAll = (routes) => contextWith2((context3) => {
+    const middleware2 = getMiddleware(context3);
+    const applyMiddleware = (effect2) => {
+      for (let i = 0;i < middleware2.length; i++) {
+        effect2 = middleware2[i](effect2);
+      }
+      return effect2;
+    };
+    for (let i = 0;i < routes.length; i++) {
+      const route = middleware2.length === 0 ? routes[i] : makeRoute({
+        ...routes[i],
+        handler: applyMiddleware(routes[i].handler)
+      });
+      if (route.method === "*") {
+        if (route.path.endsWith("/*")) {
+          router.all(route.path, route);
+          router.all(route.path.slice(0, -2), route);
+        } else {
+          router.all(route.path, route);
+        }
+      } else {
+        if (route.path.endsWith("/*")) {
+          router.on(route.method, route.path, route);
+          router.on(route.method, route.path.slice(0, -2), route);
+        } else {
+          router.on(route.method, route.path, route);
+        }
+      }
+    }
+    return void_5;
+  });
+  return HttpRouter.of({
+    [TypeId61]: TypeId61,
+    prefixed(prefix3) {
+      prefix3 = removeTrailingSlash(prefix3);
+      return HttpRouter.of({
+        ...this,
+        prefixed: (newPrefix) => this.prefixed(prefixPath(newPrefix, prefix3)),
+        addAll: (routes) => addAll(routes.map(prefixRoute(prefix3))),
+        add: (method, path, handler, options3) => addAll([makeRoute({
+          method,
+          path: prefixPath(path, prefix3),
+          handler: isHttpServerResponse(handler) ? succeed6(handler) : isEffect2(handler) ? handler : flatMap6(HttpServerRequest, handler),
+          uninterruptible: options3?.uninterruptible ?? false,
+          prefix: prefix3
+        })])
+      });
+    },
+    addAll,
+    add: (method, path, handler, options3) => addAll([route(method, path, handler, options3)]),
+    addGlobalMiddleware: (middleware_) => sync3(() => {
+      middleware.add(middleware_);
+    }),
+    asHttpEffect() {
+      let handler = withFiber2((fiber3) => {
+        let context3 = fiber3.context;
+        const request3 = getUnsafe(context3, HttpServerRequest);
+        let result6 = router.find(request3.method, request3.url);
+        if (result6 === undefined && request3.method === "HEAD") {
+          result6 = router.find("GET", request3.url);
+        }
+        if (result6 === undefined) {
+          return fail6(new HttpServerError({
+            reason: new RouteNotFound({
+              request: request3
+            })
+          }));
+        }
+        const route = result6.handler;
+        if (isSome2(route.prefix)) {
+          context3 = add(context3, HttpServerRequest, sliceRequestUrl(request3, route.prefix.value));
+        }
+        context3 = add(context3, ParsedSearchParams, result6.searchParams);
+        context3 = add(context3, RouteContext, {
+          route,
+          params: result6.params
+        });
+        if (fiber3.getRef(Tracer) !== nativeTracer) {
+          const span3 = getOrUndefined2(context3, ParentSpan);
+          if (span3 !== undefined && span3._tag === "Span" && span3.sampled) {
+            span3.attribute("http.route", route.path);
+          }
+        }
+        fiber3.setContext(context3);
+        if (!route.uninterruptible) {
+          const interrupted = fiberEnterInterruptibleUnsafe(fiber3);
+          if (interrupted !== undefined)
+            return interrupted;
+        }
+        return route.handler;
+      });
+      if (middleware.size === 0)
+        return handler;
+      for (const fn5 of reverse(middleware)) {
+        handler = fn5(handler);
+      }
+      return handler;
+    }
+  });
+});
+function sliceRequestUrl(request3, prefix3) {
+  const prefexLen = prefix3.length;
+  return request3.modify({
+    url: request3.url.length <= prefexLen ? "/" : request3.url.slice(prefexLen)
+  });
+}
+var RouterConfig = /* @__PURE__ */ Reference("effect/http/HttpRouter/RouterConfig", {
+  defaultValue: () => ({})
+});
+
+class RouteContext extends (/* @__PURE__ */ Service()("effect/http/HttpRouter/RouteContext")) {
+}
+var params = /* @__PURE__ */ withFiberSucceed2((fiber3) => getUnsafe(fiber3.context, RouteContext).params);
+var schemaJson3 = (schema2, options3) => {
+  const parse4 = decodeUnknownEffect2(schema2);
+  const parseBody = schemaBodyJson2(Unknown2, options3);
+  return contextWith2((context3) => {
+    const request3 = get(context3, HttpServerRequest);
+    const searchParams = get(context3, ParsedSearchParams);
+    const routeContext = get(context3, RouteContext);
+    return flatMap6(parseBody(request3), (body) => parse4({
+      method: request3.method,
+      url: request3.url,
+      headers: request3.headers,
+      cookies: request3.cookies,
+      pathParams: routeContext.params,
+      searchParams,
+      body
+    }, options3));
+  });
+};
+var schemaNoBody = (schema2, options3) => {
+  const parse4 = decodeUnknownEffect2(schema2);
+  return contextWith2((context3) => {
+    const request3 = get(context3, HttpServerRequest);
+    const searchParams = get(context3, ParsedSearchParams);
+    const routeContext = get(context3, RouteContext);
+    return parse4({
+      method: request3.method,
+      url: request3.url,
+      headers: request3.headers,
+      cookies: request3.cookies,
+      pathParams: routeContext.params,
+      searchParams
+    }, options3);
+  });
+};
+var schemaParams = (schema2, options3) => {
+  const parse4 = decodeUnknownEffect2(schema2);
+  return contextWith2((context3) => {
+    const searchParams = get(context3, ParsedSearchParams);
+    const routeContext = get(context3, RouteContext);
+    return parse4({
+      ...searchParams,
+      ...routeContext.params
+    }, options3);
+  });
+};
+var schemaPathParams = (schema2, options3) => {
+  const parse4 = decodeUnknownEffect2(schema2);
+  return flatMap6(params, (_) => parse4(_, options3));
+};
+var use = (f) => effectDiscard(flatMap6(HttpRouter, f));
+var add5 = (method, path, handler, options3) => use((router) => router.add(method, path, handler, options3));
+var addAll = (routes, options3) => effectDiscard(gen4(function* () {
+  const toAdd = isEffect2(routes) ? yield* routes : routes;
+  let router = yield* HttpRouter;
+  if (options3?.prefix) {
+    router = router.prefixed(options3.prefix);
+  }
+  yield* router.addAll(toAdd);
+}));
+var layer15 = /* @__PURE__ */ effect(HttpRouter)(make61);
+var toHttpEffect = (appLayer) => contextWith2((context3) => {
+  const scope3 = get(context3, Scope);
+  const memoMap = CurrentMemoMap.forkOrCreate(context3);
+  return map9(buildWithMemoMap(provideMerge(appLayer, layer15), memoMap, scope3), (context4) => {
+    const router = get(context4, HttpRouter);
+    return router.asHttpEffect();
+  });
+});
+var RouteTypeId = "~effect/http/HttpRouter/Route";
+var makeRoute = (options3) => ({
+  ...options3,
+  uninterruptible: options3.uninterruptible ?? false,
+  prefix: typeof options3.prefix === "string" ? some3(options3.prefix) : options3.prefix ?? none2(),
+  [RouteTypeId]: RouteTypeId
+});
+var route = (method, path, handler, options3) => makeRoute({
+  ...options3,
+  method,
+  path,
+  handler: isHttpServerResponse(handler) ? succeed6(handler) : isEffect2(handler) ? handler : flatMap6(HttpServerRequest, handler),
+  uninterruptible: options3?.uninterruptible ?? false
+});
+var removeTrailingSlash = (path) => path.endsWith("/") ? path.slice(0, -1) : path;
+var prefixPath = /* @__PURE__ */ dual(2, (self, prefix3) => {
+  prefix3 = removeTrailingSlash(prefix3);
+  if (self === "*")
+    return `${prefix3}/*`;
+  else if (self === "/")
+    return prefix3;
+  return prefix3 + self;
+});
+var prefixRoute = /* @__PURE__ */ dual(2, (self, prefix3) => makeRoute({
+  ...self,
+  path: prefixPath(self.path, prefix3),
+  prefix: match(self.prefix, {
+    onNone: () => removeTrailingSlash(prefix3),
+    onSome: (existingPrefix) => prefixPath(existingPrefix, prefix3)
+  })
+}));
+var MiddlewareTypeId = "~effect/http/HttpRouter/Middleware";
+var middleware = function() {
+  if (arguments.length === 0) {
+    return makeMiddleware;
+  }
+  return makeMiddleware(arguments[0], arguments[1]);
+};
+var makeMiddleware = (middleware2, options3) => options3?.global ? effectDiscard(gen4(function* () {
+  const router = yield* HttpRouter;
+  const fn5 = isEffect2(middleware2) ? yield* middleware2 : middleware2;
+  yield* router.addGlobalMiddleware(fn5);
+})) : new MiddlewareImpl(isEffect2(middleware2) ? effectContext(map9(middleware2, (fn5) => makeUnsafe(new Map([[fnContextKey, fn5]])))) : succeedContext(makeUnsafe(new Map([[fnContextKey, middleware2]]))));
+var middlewareId = 0;
+var fnContextKey = "effect/http/HttpRouter/MiddlewareFn";
+
+class MiddlewareImpl {
+  [MiddlewareTypeId] = {};
+  layerFn;
+  dependencies;
+  constructor(layerFn, dependencies) {
+    this.layerFn = layerFn;
+    this.dependencies = dependencies;
+    const contextKey = `effect/http/HttpRouter/Middleware-${++middlewareId}`;
+    this.layer = effectContext(gen4({
+      self: this
+    }, function* () {
+      const context3 = yield* context2();
+      const stack = [getOrUndefinedUnsafe(context3, fnContextKey)];
+      if (this.dependencies) {
+        const memoMap = yield* CurrentMemoMap;
+        const scope3 = get(context3, Scope);
+        const depsContext = yield* buildWithMemoMap(this.dependencies, memoMap, scope3);
+        stack.push(...getMiddleware(depsContext));
+      }
+      return makeUnsafe(new Map([[contextKey, stack]]));
+    })).pipe(provide2(this.layerFn));
+  }
+  layer;
+  combine(other) {
+    return new MiddlewareImpl(this.layerFn, this.dependencies ? provideMerge(this.dependencies, other.layer) : other.layer);
+  }
+}
+var middlewareCache = /* @__PURE__ */ new WeakMap;
+var getMiddleware = (context3) => {
+  let arr = middlewareCache.get(context3);
+  if (arr)
+    return arr;
+  const topLevel = empty3();
+  let maxLength = 0;
+  for (const [key, value5] of context3.mapUnsafe) {
+    if (key.startsWith("effect/http/HttpRouter/Middleware-")) {
+      topLevel.push(value5);
+      if (value5.length > maxLength) {
+        maxLength = value5.length;
+      }
+    }
+  }
+  if (topLevel.length === 0) {
+    arr = [];
+  } else {
+    const middleware2 = new Set;
+    for (let i = maxLength - 1;i >= 0; i--) {
+      for (const arr2 of topLevel) {
+        if (i < arr2.length) {
+          middleware2.add(arr2[i]);
+        }
+      }
+    }
+    arr = fromIterable2(middleware2).reverse();
+  }
+  middlewareCache.set(context3, arr);
+  return arr;
+};
+var cors2 = (options3) => middleware(cors(options3), {
+  global: true
+});
+var disableLogger = middleware(withLoggerDisabled).layer;
+var provideRequest = (layer16) => (self) => provide2(self, middleware()(gen4(function* () {
+  const services = yield* build(layer16);
+  return (effect2) => provideContext2(effect2, services);
+})).layer);
+var serve2 = (appLayer, options3) => {
+  let middleware2 = options3?.middleware;
+  if (options3?.disableLogger !== true) {
+    middleware2 = middleware2 ? compose(middleware2, logger) : logger;
+  }
+  const layerWithRouter = provideMerge(appLayer, options3?.routerConfig ? provide2(layer15, succeed5(RouterConfig)(options3.routerConfig)) : layer15);
+  return contextWith2((context3) => {
+    const memoMap = CurrentMemoMap.forkOrCreate(context3);
+    return buildWithMemoMap(layerWithRouter, memoMap, get(context3, Scope));
+  }).pipe(map9((context3) => {
+    const router = get(context3, HttpRouter);
+    const handler = router.asHttpEffect();
+    return merge3(middleware2 ? serve(handler, middleware2) : serve(handler), succeedContext(context3));
+  }), unwrap, options3?.disableListenLog ? identity : withLogAddress);
+};
+var toWebHandler = (appLayer, options3) => {
+  let middleware2 = options3?.middleware;
+  if (options3?.disableLogger !== true) {
+    middleware2 = middleware2 ? compose(middleware2, logger) : logger;
+  }
+  const RouterLayer = options3?.routerConfig ? provide2(layer15, succeed5(RouterConfig)(options3.routerConfig)) : layer15;
+  return toWebHandlerLayerWith(provideMerge(appLayer, RouterLayer), {
+    toHandler: (s) => succeed6(get(s, HttpRouter).asHttpEffect()),
+    middleware: middleware2,
+    memoMap: options3?.memoMap
+  });
+};
 // ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/cli/Argument.js
 var exports_Argument = {};
 __export(exports_Argument, {
@@ -38281,15 +40105,15 @@ __export(exports_CliError, {
   InvalidValue: () => InvalidValue2,
   DuplicateOption: () => DuplicateOption
 });
-var TypeId61 = "~effect/cli/CliError";
-var isCliError = (u) => hasProperty(u, TypeId61);
+var TypeId62 = "~effect/cli/CliError";
+var isCliError = (u) => hasProperty(u, TypeId62);
 
-class UnrecognizedOption extends (/* @__PURE__ */ TaggedError3(`${TypeId61}/UnrecognizedOption`)("UnrecognizedOption", {
+class UnrecognizedOption extends (/* @__PURE__ */ TaggedError3(`${TypeId62}/UnrecognizedOption`)("UnrecognizedOption", {
   option: String7,
   command: /* @__PURE__ */ optional2(/* @__PURE__ */ ArraySchema(String7)),
   suggestions: /* @__PURE__ */ ArraySchema(String7)
 })) {
-  [TypeId61] = TypeId61;
+  [TypeId62] = TypeId62;
   get message() {
     const suggestionText = this.suggestions.length > 0 ? `
 
@@ -38301,52 +40125,52 @@ class UnrecognizedOption extends (/* @__PURE__ */ TaggedError3(`${TypeId61}/Unre
   }
 }
 
-class DuplicateOption extends (/* @__PURE__ */ TaggedError3(`${TypeId61}/DuplicateOption`)("DuplicateOption", {
+class DuplicateOption extends (/* @__PURE__ */ TaggedError3(`${TypeId62}/DuplicateOption`)("DuplicateOption", {
   option: String7,
   parentCommand: String7,
   childCommand: String7
 })) {
-  [TypeId61] = TypeId61;
+  [TypeId62] = TypeId62;
   get message() {
     return `Duplicate flag name "${this.option}" in parent command "${this.parentCommand}" and subcommand "${this.childCommand}". ` + `Parent will always claim this flag (Mode A semantics). Consider renaming one of them to avoid confusion.`;
   }
 }
 
-class MissingOption extends (/* @__PURE__ */ TaggedError3(`${TypeId61}/MissingOption`)("MissingOption", {
+class MissingOption extends (/* @__PURE__ */ TaggedError3(`${TypeId62}/MissingOption`)("MissingOption", {
   option: String7
 })) {
-  [TypeId61] = TypeId61;
+  [TypeId62] = TypeId62;
   get message() {
     return `Missing required flag: --${this.option}`;
   }
 }
 
-class MissingArgument extends (/* @__PURE__ */ TaggedError3(`${TypeId61}/MissingArgument`)("MissingArgument", {
+class MissingArgument extends (/* @__PURE__ */ TaggedError3(`${TypeId62}/MissingArgument`)("MissingArgument", {
   argument: String7
 })) {
-  [TypeId61] = TypeId61;
+  [TypeId62] = TypeId62;
   get message() {
     return `Missing required argument: ${this.argument}`;
   }
 }
 
-class UnexpectedArgument extends (/* @__PURE__ */ TaggedError3(`${TypeId61}/UnexpectedArgument`)("UnexpectedArgument", {
+class UnexpectedArgument extends (/* @__PURE__ */ TaggedError3(`${TypeId62}/UnexpectedArgument`)("UnexpectedArgument", {
   arguments: /* @__PURE__ */ ArraySchema(String7)
 })) {
-  [TypeId61] = TypeId61;
+  [TypeId62] = TypeId62;
   get message() {
     const label = this.arguments.length === 1 ? "argument" : "arguments";
     return `Unexpected positional ${label}: ${this.arguments.map((value5) => JSON.stringify(value5)).join(", ")}`;
   }
 }
 
-class InvalidValue2 extends (/* @__PURE__ */ TaggedError3(`${TypeId61}/InvalidValue`)("InvalidValue", {
+class InvalidValue2 extends (/* @__PURE__ */ TaggedError3(`${TypeId62}/InvalidValue`)("InvalidValue", {
   option: String7,
   value: String7,
   expected: String7,
   kind: /* @__PURE__ */ Union2([/* @__PURE__ */ Literal2("flag"), /* @__PURE__ */ Literal2("argument")])
 })) {
-  [TypeId61] = TypeId61;
+  [TypeId62] = TypeId62;
   get message() {
     const expectation = this.expected.startsWith("Expected ") || this.expected.startsWith("Expected:") ? this.expected : `Expected: ${this.expected}`;
     if (this.kind === "argument") {
@@ -38359,12 +40183,12 @@ class InvalidValue2 extends (/* @__PURE__ */ TaggedError3(`${TypeId61}/InvalidVa
   }
 }
 
-class UnknownSubcommand extends (/* @__PURE__ */ TaggedError3(`${TypeId61}/UnknownSubcommand`)("UnknownSubcommand", {
+class UnknownSubcommand extends (/* @__PURE__ */ TaggedError3(`${TypeId62}/UnknownSubcommand`)("UnknownSubcommand", {
   subcommand: String7,
   parent: /* @__PURE__ */ optional2(/* @__PURE__ */ ArraySchema(String7)),
   suggestions: /* @__PURE__ */ ArraySchema(String7)
 })) {
-  [TypeId61] = TypeId61;
+  [TypeId62] = TypeId62;
   get message() {
     const suggestionText = this.suggestions.length > 0 ? `
 
@@ -38375,11 +40199,11 @@ class UnknownSubcommand extends (/* @__PURE__ */ TaggedError3(`${TypeId61}/Unkno
   }
 }
 
-class UserError extends (/* @__PURE__ */ TaggedError3(`${TypeId61}/UserError`)("UserError", {
+class UserError extends (/* @__PURE__ */ TaggedError3(`${TypeId62}/UserError`)("UserError", {
   cause: /* @__PURE__ */ Defect(),
   userMessage: /* @__PURE__ */ optionalKey2(String7)
 })) {
-  [TypeId61] = TypeId61;
+  [TypeId62] = TypeId62;
   [errorReported] = true;
   get message() {
     if (this.userMessage)
@@ -38393,11 +40217,11 @@ class UserError extends (/* @__PURE__ */ TaggedError3(`${TypeId61}/UserError`)("
 }
 var NonShowHelpErrors = /* @__PURE__ */ Union2([UnrecognizedOption, DuplicateOption, MissingOption, MissingArgument, UnexpectedArgument, InvalidValue2, UnknownSubcommand, UserError]);
 
-class ShowHelp extends (/* @__PURE__ */ TaggedError3(`${TypeId61}/ShowHelp`)("ShowHelp", {
+class ShowHelp extends (/* @__PURE__ */ TaggedError3(`${TypeId62}/ShowHelp`)("ShowHelp", {
   commandPath: /* @__PURE__ */ ArraySchema(String7),
   errors: /* @__PURE__ */ ArraySchema(NonShowHelpErrors)
 })) {
-  [TypeId61] = TypeId61;
+  [TypeId62] = TypeId62;
   [errorExitCode] = this.errors.length ? 1 : 0;
   [errorReported] = false;
   get message() {
@@ -38450,7 +40274,7 @@ var unquote = (input) => {
   }
   return output.trim();
 };
-var parse3 = (input) => {
+var parse4 = (input) => {
   const output = Object.create(null);
   let current = output;
   const sectionPattern = /^\[([^\]]*)\]\s*$/;
@@ -38958,12 +40782,12 @@ class TomlParser {
     throw new SyntaxError(`${message} at line ${this.line}, column ${this.column}`);
   }
 }
-var parse4 = (input) => new TomlParser(input.replace(/^\uFEFF/, "")).parse();
+var parse5 = (input) => new TomlParser(input.replace(/^\uFEFF/, "")).parse();
 
 // ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/encoding/Yaml.js
 var exports_Yaml = {};
 __export(exports_Yaml, {
-  parse: () => parse5
+  parse: () => parse6
 });
 var hasOwn3 = Object.prototype.hasOwnProperty;
 var setProperty = (record3, key, value5) => {
@@ -39521,7 +41345,7 @@ class YamlParser {
     throw new SyntaxError(`${message} at line ${line.number}`);
   }
 }
-var parse5 = (input) => {
+var parse6 = (input) => {
   const source = input.replace(/^\uFEFF/, "").replace(/\r\n?/g, `
 `);
   const lines = source.split(`
@@ -39541,18 +41365,18 @@ var parse5 = (input) => {
 };
 
 // ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/cli/Primitive.js
-var TypeId62 = "~effect/cli/Primitive";
+var TypeId63 = "~effect/cli/Primitive";
 var Proto16 = {
-  [TypeId62]: {
+  [TypeId63]: {
     _A: identity
   }
 };
 var isTrueLiteral = /* @__PURE__ */ is2(TrueLiterals);
 var isFalseLiteral = /* @__PURE__ */ is2(FalseLiterals);
 var isBoolean3 = (p) => p._tag === "Boolean";
-var makePrimitive2 = (tag4, parse6) => Object.assign(Object.create(Proto16), {
+var makePrimitive2 = (tag4, parse7) => Object.assign(Object.create(Proto16), {
   _tag: tag4,
-  parse: parse6
+  parse: parse7
 });
 var makeSchemaPrimitive = (tag4, schema2) => {
   const toCodecStringTree3 = toCodecStringTree2(schema2);
@@ -39618,11 +41442,11 @@ var FileText = /* @__PURE__ */ makePrimitive2("FileText", /* @__PURE__ */ fnUntr
   return content;
 }));
 var fileParsers = {
-  ini: (content) => parse3(content),
+  ini: (content) => parse4(content),
   json: (content) => JSON.parse(content),
-  toml: (content) => parse4(content),
-  yml: (content) => parse5(content),
-  yaml: (content) => parse5(content)
+  toml: (content) => parse5(content),
+  yml: (content) => parse6(content),
+  yaml: (content) => parse6(content)
 };
 var FileParse = (options3) => {
   return makePrimitive2("FileParse", fnUntraced2(function* (filePath) {
@@ -39764,8 +41588,8 @@ var eraseLines = (rows) => {
 };
 
 // ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/cli/Prompt.js
-var TypeId63 = "~effect/cli/Prompt";
-var isPrompt = (u) => hasProperty(u, TypeId63);
+var TypeId64 = "~effect/cli/Prompt";
+var isPrompt = (u) => hasProperty(u, TypeId64);
 var defaultTheme = {
   prefix: "?",
   arrowUp: "↑",
@@ -40011,7 +41835,7 @@ var proto = {
       return run3(this);
     }
   }),
-  [TypeId63]: {
+  [TypeId64]: {
     _Output: (_) => _
   }
 };
@@ -40408,11 +42232,11 @@ class DatePart {
   date;
   parts;
   locales;
-  constructor(params) {
-    this.token = params.token;
-    this.locales = params.locales;
-    this.date = params.date || new globalThis.Date;
-    this.parts = params.parts || [this];
+  constructor(params2) {
+    this.token = params2.token;
+    this.locales = params2.locales;
+    this.date = params2.date || new globalThis.Date;
+    this.parts = params2.parts || [this];
   }
   isToken() {
     return false;
@@ -41422,28 +43246,28 @@ var entriesToDisplay = (cursor, total, maxVisible) => {
 };
 
 // ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/cli/Param.js
-var TypeId64 = "~effect/cli/Param";
+var TypeId65 = "~effect/cli/Param";
 var argumentKind = "argument";
 var flagKind = "flag";
 var Proto17 = {
-  [TypeId64]: {
+  [TypeId65]: {
     _A: identity
   },
   pipe() {
     return pipeArguments(this, arguments);
   }
 };
-var isParam = (u) => hasProperty(u, TypeId64);
+var isParam = (u) => hasProperty(u, TypeId65);
 var isFlagParam = (single) => single.kind === "flag";
-var makeSingle2 = (params) => {
-  const parse6 = (args2) => params.kind === argumentKind ? parsePositional(params.name, params.primitiveType, args2) : parseFlag(params.name, params.primitiveType, args2);
+var makeSingle2 = (params2) => {
+  const parse7 = (args2) => params2.kind === argumentKind ? parsePositional(params2.name, params2.primitiveType, args2) : parseFlag(params2.name, params2.primitiveType, args2);
   return Object.setPrototypeOf({
     _tag: "Single",
-    ...params,
-    description: params.description ?? none2(),
-    aliases: params.aliases ?? [],
-    hidden: params.hidden ?? false,
-    parse: parse6
+    ...params2,
+    description: params2.description ?? none2(),
+    aliases: params2.aliases ?? [],
+    hidden: params2.hidden ?? false,
+    parse: parse7
   }, Proto17);
 };
 var String12 = (kind, name) => makeSingle2({
@@ -41546,13 +43370,13 @@ var withHidden = (self) => transformSingle(self, (single) => makeSingle2({
   hidden: true
 }));
 var map17 = /* @__PURE__ */ dual(2, (self, f) => {
-  const parse6 = (args2) => map9(self.parse(args2), ([operands, value5]) => [operands, f(value5)]);
+  const parse7 = (args2) => map9(self.parse(args2), ([operands, value5]) => [operands, f(value5)]);
   return Object.assign(Object.create(Proto17), {
     _tag: "Map",
     kind: self.kind,
     param: self,
     f,
-    parse: parse6
+    parse: parse7
   });
 });
 var transform5 = (self, f, alternatives = []) => {
@@ -41566,10 +43390,10 @@ var transform5 = (self, f, alternatives = []) => {
     parse: f(self.parse, alternativeParsers)
   });
 };
-var mapEffect4 = /* @__PURE__ */ dual(2, (self, f) => transform5(self, (parse6) => (args2) => flatMap6(parse6(args2), ([leftover, a]) => f(a).pipe(map9((b) => [leftover, b])))));
+var mapEffect4 = /* @__PURE__ */ dual(2, (self, f) => transform5(self, (parse7) => (args2) => flatMap6(parse7(args2), ([leftover, a]) => f(a).pipe(map9((b) => [leftover, b])))));
 var mapTryCatch = /* @__PURE__ */ dual(3, (self, f, onError5) => {
   const single = getUnderlyingSingleOrThrow(self);
-  return transform5(self, (parse6) => (args2) => flatMap6(parse6(args2), ([leftover, a]) => try_3({
+  return transform5(self, (parse7) => (args2) => flatMap6(parse7(args2), ([leftover, a]) => try_3({
     try: () => f(a),
     catch: (error2) => onError5(error2)
   }).pipe(mapError4((error2) => new InvalidValue2({
@@ -41580,7 +43404,7 @@ var mapTryCatch = /* @__PURE__ */ dual(3, (self, f, onError5) => {
   })), map9((b) => [leftover, b]))));
 });
 var optional3 = (param) => {
-  const parse6 = (args2) => param.parse(args2).pipe(map9(([leftover, value5]) => [leftover, some3(value5)]), catchTags2({
+  const parse7 = (args2) => param.parse(args2).pipe(map9(([leftover, value5]) => [leftover, some3(value5)]), catchTags2({
     MissingOption: () => succeed6([args2.arguments, none2()]),
     MissingArgument: () => succeed6([args2.arguments, none2()])
   }));
@@ -41588,7 +43412,7 @@ var optional3 = (param) => {
     _tag: "Optional",
     kind: param.kind,
     param,
-    parse: parse6
+    parse: parse7
   });
 };
 var withDefault4 = /* @__PURE__ */ dual(2, (self, defaultValue) => {
@@ -41611,15 +43435,15 @@ var withFallbackConfig = /* @__PURE__ */ dual(2, (self, config) => {
     onNone: () => fail6(error2),
     onSome: (value5) => succeed6([args2.arguments, value5])
   })));
-  return transform5(self, (parse6) => (args2) => parse6(args2).pipe(catchTag3(["MissingOption", "MissingArgument"], (error2) => runConfig(error2, args2))));
+  return transform5(self, (parse7) => (args2) => parse7(args2).pipe(catchTag3(["MissingOption", "MissingArgument"], (error2) => runConfig(error2, args2))));
 });
 var withFallbackPrompt = /* @__PURE__ */ dual(2, (self, prompt) => {
   const runPrompt = (error2, args2) => flatMap6(isPrompt(prompt) ? succeed6(prompt) : prompt, run3).pipe(map9((value5) => [args2.arguments, value5]), catchTag3("QuitError", () => fail6(error2)));
-  return transform5(self, (parse6) => (args2) => parse6(args2).pipe(catchTag3(["MissingOption", "MissingArgument"], (error2) => runPrompt(error2, args2))));
+  return transform5(self, (parse7) => (args2) => parse7(args2).pipe(catchTag3(["MissingOption", "MissingArgument"], (error2) => runPrompt(error2, args2))));
 });
 var variadic = (self, options3) => {
   const single = getUnderlyingSingleOrThrow(self);
-  const parse6 = (args2) => {
+  const parse7 = (args2) => {
     if (single.kind === "argument") {
       return parsePositionalVariadic(self, single, args2, options3);
     } else {
@@ -41632,7 +43456,7 @@ var variadic = (self, options3) => {
     param: self,
     min: fromUndefinedOr(options3?.min),
     max: fromUndefinedOr(options3?.max),
-    parse: parse6
+    parse: parse7
   });
 };
 var between5 = /* @__PURE__ */ dual(3, (self, min9, max9) => {
@@ -41693,9 +43517,9 @@ var withSchema = /* @__PURE__ */ dual(2, (self, schema2) => {
     });
   }));
 });
-var orElse6 = /* @__PURE__ */ dual(2, (self, orElse7) => transform5(self, (parse6, alternatives) => (args2) => catch_3(parse6(args2), () => alternatives[0]()(args2)), [orElse7]));
+var orElse6 = /* @__PURE__ */ dual(2, (self, orElse7) => transform5(self, (parse7, alternatives) => (args2) => catch_3(parse7(args2), () => alternatives[0]()(args2)), [orElse7]));
 var orElseResult2 = /* @__PURE__ */ dual(2, (self, orElse7) => {
-  return transform5(self, (parse6, alternatives) => (args2) => catch_3(map9(parse6(args2), ([leftover, value5]) => [leftover, succeed2(value5)]), () => map9(alternatives[0]()(args2), ([leftover, value5]) => [leftover, fail2(value5)])), [orElse7]);
+  return transform5(self, (parse7, alternatives) => (args2) => catch_3(map9(parse7(args2), ([leftover, value5]) => [leftover, succeed2(value5)]), () => map9(alternatives[0]()(args2), ([leftover, value5]) => [leftover, fail2(value5)])), [orElse7]);
 });
 var parsePositional = /* @__PURE__ */ fnUntraced2(function* (name, primitiveType, args2) {
   if (args2.arguments.length === 0) {
@@ -41910,7 +43734,7 @@ __export(exports_Command, {
   provideEffectDiscard: () => provideEffectDiscard,
   provideEffect: () => provideEffect,
   provide: () => provide7,
-  make: () => make58,
+  make: () => make62,
   isCommand: () => isCommand2,
   annotateMerge: () => annotateMerge,
   annotate: () => annotate5
@@ -43147,7 +44971,7 @@ var parseConfig = (config) => {
   const orderedParams = [];
   const flags = [];
   const args2 = [];
-  function parse6(config2) {
+  function parse7(config2) {
     const tree = Object.create(null);
     for (const key of Object.keys(config2)) {
       tree[key] = parseValue(config2[key]);
@@ -43175,7 +44999,7 @@ var parseConfig = (config) => {
     } else {
       return {
         _tag: "Nested",
-        tree: parse6(value5)
+        tree: parse7(value5)
       };
     }
   }
@@ -43184,7 +45008,7 @@ var parseConfig = (config) => {
     flags,
     arguments: args2,
     orderedParams,
-    tree: parse6(config)
+    tree: parse7(config)
   };
 };
 var emptyConfig = /* @__PURE__ */ parseConfig({});
@@ -43243,7 +45067,7 @@ var reconstructTree = (tree, results2) => {
 };
 
 // ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/cli/internal/command.js
-var TypeId65 = "~effect/cli/Command";
+var TypeId66 = "~effect/cli/Command";
 var toImpl2 = (self) => self;
 var Proto18 = {
   .../* @__PURE__ */ Prototype2({
@@ -43256,7 +45080,7 @@ var Proto18 = {
 var makeCommand = (options3) => {
   const config = options3.config;
   const contextConfig = options3.contextConfig ?? emptyConfig;
-  const service4 = options3.service ?? Service(`${TypeId65}/${options3.name}`);
+  const service4 = options3.service ?? Service(`${TypeId66}/${options3.name}`);
   const annotations2 = options3.annotations ?? empty();
   const globalFlags = options3.globalFlags ?? [];
   const subcommands = options3.subcommands ?? [];
@@ -43264,7 +45088,7 @@ var makeCommand = (options3) => {
     commandPath,
     errors: []
   }));
-  const parse6 = options3.parse ?? makeParser(config);
+  const parse7 = options3.parse ?? makeParser(config);
   const parseContext = options3.parseContext ?? makeParser(contextConfig, {
     allowLeftovers: true
   });
@@ -43335,7 +45159,7 @@ var makeCommand = (options3) => {
     };
   };
   return Object.assign(Object.create(Proto18), {
-    [TypeId65]: TypeId65,
+    [TypeId66]: TypeId66,
     name: options3.name,
     examples: options3.examples ?? [],
     annotations: annotations2,
@@ -43345,7 +45169,7 @@ var makeCommand = (options3) => {
     config,
     contextConfig,
     service: service4,
-    parse: parse6,
+    parse: parse7,
     parseContext,
     handle,
     buildHelpDoc,
@@ -43393,10 +45217,10 @@ var makeParser = (cfg, options3) => fnUntraced2(function* (input) {
   }
   return reconstructTree(cfg.tree, values4);
 });
-var parseParams = /* @__PURE__ */ fnUntraced2(function* (parsedArgs, params) {
+var parseParams = /* @__PURE__ */ fnUntraced2(function* (parsedArgs, params2) {
   const results2 = [];
   let currentArguments = parsedArgs.arguments;
-  for (const option6 of params) {
+  for (const option6 of params2) {
     const [remainingArguments, parsed] = yield* option6.parse({
       flags: parsedArgs.flags,
       arguments: currentArguments
@@ -43919,9 +45743,9 @@ var makeCursor = (tokens) => {
     rest: () => tokens.slice(i)
   };
 };
-var createFlagRegistry = (params) => {
+var createFlagRegistry = (params2) => {
   const index2 = new Map;
-  for (const param of params) {
+  for (const param of params2) {
     if (index2.has(param.name)) {
       throw new Error(`Duplicate flag name "${param.name}" in command definition`);
     }
@@ -43934,7 +45758,7 @@ var createFlagRegistry = (params) => {
     }
   }
   return {
-    params,
+    params: params2,
     index: index2
   };
 };
@@ -43957,9 +45781,9 @@ var buildSubcommandIndex = (subcommands) => {
   }
   return index2;
 };
-var createEmptyFlagMap = (params) => Object.fromEntries(params.map((p) => [p.name, []]));
-var createFlagAccumulator = (params) => {
-  const map20 = createEmptyFlagMap(params);
+var createEmptyFlagMap = (params2) => Object.fromEntries(params2.map((p) => [p.name, []]));
+var createFlagAccumulator = (params2) => {
+  const map20 = createEmptyFlagMap(params2);
   return {
     add: (name, raw3) => {
       if (raw3 !== undefined)
@@ -44227,10 +46051,10 @@ var consumeGlobalFlags = (tokens, command, registry) => {
     errors
   };
 };
-var createUnrecognizedFlagError = (token, params, commandPath) => {
+var createUnrecognizedFlagError = (token, params2, commandPath) => {
   const printable = token._tag === "LongOption" ? `--${token.name}` : `-${token.flag}`;
   const validNames = [];
-  for (const p of params) {
+  for (const p of params2) {
     if (p.hidden)
       continue;
     validNames.push(p.name);
@@ -44581,8 +46405,8 @@ var wrapCommand = (commandLine) => {
 var formatShellArg = (arg) => /^[A-Za-z0-9_./:@%+=,-]+$/.test(arg) ? arg : `'${arg.replaceAll("'", `'"'"'`)}'`;
 
 // ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/cli/Command.js
-var isCommand2 = (u) => hasProperty(u, TypeId65);
-var make58 = (name, config, handler) => {
+var isCommand2 = (u) => hasProperty(u, TypeId66);
+var make62 = (name, config, handler) => {
   const parsedConfig = parseConfig(config ?? {});
   return makeCommand({
     name,
@@ -44645,7 +46469,7 @@ var withSubcommands = /* @__PURE__ */ dual(2, (self, subcommands) => {
   const impl = toImpl2(self);
   const byName = new Map(normalized.flat.map((s) => [s.name, toImpl2(s)]));
   const SubcommandStateSymbol = Symbol("effect/cli/SubcommandState");
-  const parse6 = fnUntraced2(function* (raw3) {
+  const parse7 = fnUntraced2(function* (raw3) {
     if (isNone2(raw3.subcommand)) {
       return yield* impl.parse(raw3);
     }
@@ -44691,7 +46515,7 @@ var withSubcommands = /* @__PURE__ */ dual(2, (self, subcommands) => {
     examples: impl.examples,
     service: impl.service,
     subcommands: normalized.groups,
-    parse: parse6,
+    parse: parse7,
     parseContext: impl.parseContext,
     handle
   });
@@ -44710,7 +46534,7 @@ var withSharedFlags = /* @__PURE__ */ dual(2, (self, sharedFlags) => {
   const parseShared = makeParser(sharedConfig, {
     allowLeftovers: true
   });
-  const parse6 = fnUntraced2(function* (raw3) {
+  const parse7 = fnUntraced2(function* (raw3) {
     const base = yield* impl.parse(raw3);
     const shared = yield* parseShared(raw3);
     return {
@@ -44740,7 +46564,7 @@ var withSharedFlags = /* @__PURE__ */ dual(2, (self, sharedFlags) => {
     examples: impl.examples,
     service: impl.service,
     subcommands: impl.subcommands,
-    parse: parse6,
+    parse: parse7,
     parseContext,
     handle
   });
@@ -44794,7 +46618,7 @@ var mapHandler = (self, f) => {
     handle: (input, path) => f(impl.handle(input, path), input)
   });
 };
-var provide7 = /* @__PURE__ */ dual((args2) => isCommand2(args2[0]), (self, layer15, options3) => mapHandler(self, (handler, input) => provide4(handler, typeof layer15 === "function" ? layer15(input) : layer15, options3)));
+var provide7 = /* @__PURE__ */ dual((args2) => isCommand2(args2[0]), (self, layer16, options3) => mapHandler(self, (handler, input) => provide4(handler, typeof layer16 === "function" ? layer16(input) : layer16, options3)));
 var provideSync = /* @__PURE__ */ dual(3, (self, service4, implementation) => mapHandler(self, (handler, input) => provideService2(handler, service4, typeof implementation === "function" ? implementation(input) : implementation)));
 var provideEffect = /* @__PURE__ */ dual(3, (self, service4, effect2) => mapHandler(self, (handler, input) => provideServiceEffect2(handler, service4, typeof effect2 === "function" ? effect2(input) : effect2)));
 var provideEffectDiscard = /* @__PURE__ */ dual(2, (self, effect2) => mapHandler(self, (handler, input) => andThen4(typeof effect2 === "function" ? effect2(input) : effect2, handler)));
@@ -44961,7 +46785,7 @@ var runWith2 = (command, config) => {
 // package.json
 var package_default = {
   name: "ambral",
-  version: "0.4.0",
+  version: "0.5.0",
   license: "UNLICENSED",
   type: "module",
   description: "The `ambral` command: signs in through the browser, then calls the platform API as that person.",
@@ -45039,7 +46863,7 @@ __export(exports_AuthApi, {
 var exports_HttpApi = {};
 __export(exports_HttpApi, {
   reflect: () => reflect,
-  make: () => make60,
+  make: () => make64,
   isHttpApi: () => isHttpApi,
   getSlotParseOptions: () => getSlotParseOptions,
   SuccessParseOptions: () => SuccessParseOptions,
@@ -45060,7 +46884,7 @@ __export(exports_HttpApiEndpoint, {
   post: () => post3,
   patch: () => patch3,
   options: () => options3,
-  make: () => make59,
+  make: () => make63,
   isHttpApiEndpoint: () => isHttpApiEndpoint,
   head: () => head6,
   getSuccessSchemas: () => getSuccessSchemas,
@@ -45070,100 +46894,6 @@ __export(exports_HttpApiEndpoint, {
   delete: () => del3
 });
 
-// ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/http/HttpMiddleware.js
-var loggerDisabledRequests = /* @__PURE__ */ new WeakSet;
-var withLoggerDisabled = (self) => withFiber2((fiber3) => {
-  const request3 = getUnsafe(fiber3.context, HttpServerRequest);
-  loggerDisabledRequests.add(request3.source);
-  return self;
-});
-
-// ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/http/HttpRouter.js
-var HttpRouter2 = /* @__PURE__ */ Service("effect/http/HttpRouter");
-var removeTrailingSlash = (path) => path.endsWith("/") ? path.slice(0, -1) : path;
-var prefixPath = /* @__PURE__ */ dual(2, (self, prefix3) => {
-  prefix3 = removeTrailingSlash(prefix3);
-  if (self === "*")
-    return `${prefix3}/*`;
-  else if (self === "/")
-    return prefix3;
-  return prefix3 + self;
-});
-var MiddlewareTypeId = "~effect/http/HttpRouter/Middleware";
-var middleware = function() {
-  if (arguments.length === 0) {
-    return makeMiddleware;
-  }
-  return makeMiddleware(arguments[0], arguments[1]);
-};
-var makeMiddleware = (middleware2, options3) => options3?.global ? effectDiscard(gen4(function* () {
-  const router = yield* HttpRouter2;
-  const fn5 = isEffect2(middleware2) ? yield* middleware2 : middleware2;
-  yield* router.addGlobalMiddleware(fn5);
-})) : new MiddlewareImpl(isEffect2(middleware2) ? effectContext(map9(middleware2, (fn5) => makeUnsafe(new Map([[fnContextKey, fn5]])))) : succeedContext(makeUnsafe(new Map([[fnContextKey, middleware2]]))));
-var middlewareId = 0;
-var fnContextKey = "effect/http/HttpRouter/MiddlewareFn";
-
-class MiddlewareImpl {
-  [MiddlewareTypeId] = {};
-  layerFn;
-  dependencies;
-  constructor(layerFn, dependencies) {
-    this.layerFn = layerFn;
-    this.dependencies = dependencies;
-    const contextKey = `effect/http/HttpRouter/Middleware-${++middlewareId}`;
-    this.layer = effectContext(gen4({
-      self: this
-    }, function* () {
-      const context3 = yield* context2();
-      const stack = [getOrUndefinedUnsafe(context3, fnContextKey)];
-      if (this.dependencies) {
-        const memoMap = yield* CurrentMemoMap;
-        const scope3 = get(context3, Scope);
-        const depsContext = yield* buildWithMemoMap(this.dependencies, memoMap, scope3);
-        stack.push(...getMiddleware(depsContext));
-      }
-      return makeUnsafe(new Map([[contextKey, stack]]));
-    })).pipe(provide2(this.layerFn));
-  }
-  layer;
-  combine(other) {
-    return new MiddlewareImpl(this.layerFn, this.dependencies ? provideMerge(this.dependencies, other.layer) : other.layer);
-  }
-}
-var middlewareCache = /* @__PURE__ */ new WeakMap;
-var getMiddleware = (context3) => {
-  let arr = middlewareCache.get(context3);
-  if (arr)
-    return arr;
-  const topLevel = empty3();
-  let maxLength = 0;
-  for (const [key, value5] of context3.mapUnsafe) {
-    if (key.startsWith("effect/http/HttpRouter/Middleware-")) {
-      topLevel.push(value5);
-      if (value5.length > maxLength) {
-        maxLength = value5.length;
-      }
-    }
-  }
-  if (topLevel.length === 0) {
-    arr = [];
-  } else {
-    const middleware2 = new Set;
-    for (let i = maxLength - 1;i >= 0; i--) {
-      for (const arr2 of topLevel) {
-        if (i < arr2.length) {
-          middleware2.add(arr2[i]);
-        }
-      }
-    }
-    arr = fromIterable2(middleware2).reverse();
-  }
-  middlewareCache.set(context3, arr);
-  return arr;
-};
-var disableLogger = middleware(withLoggerDisabled).layer;
-
 // ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/http-api/HttpApiSchema.js
 var exports_HttpApiSchema = {};
 __export(exports_HttpApiSchema, {
@@ -45200,7 +46930,7 @@ __export(exports_HttpApiSchema, {
   NoContent: () => NoContent,
   MultipartTypeId: () => MultipartTypeId,
   MultipartStreamTypeId: () => MultipartStreamTypeId,
-  Empty: () => Empty3,
+  Empty: () => Empty4,
   Created: () => Created,
   Accepted: () => Accepted
 });
@@ -45499,10 +47229,10 @@ function status(code) {
     httpApiStatus: statusCode
   });
 }
-var Empty3 = (code) => Void2.pipe(status(code));
-var NoContent = /* @__PURE__ */ Empty3(204);
-var Created = /* @__PURE__ */ Empty3(201);
-var Accepted = /* @__PURE__ */ Empty3(202);
+var Empty4 = (code) => Void2.pipe(status(code));
+var NoContent = /* @__PURE__ */ Empty4(204);
+var Created = /* @__PURE__ */ Empty4(201);
+var Accepted = /* @__PURE__ */ Empty4(202);
 function asNoContent(options3) {
   return (self) => {
     return Void2.pipe(decodeTo2(toType2(self), transform2({
@@ -45735,8 +47465,8 @@ function normalize3(contentType) {
 }
 
 // ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/http-api/HttpApiEndpoint.js
-var TypeId66 = "~effect/http-api/HttpApiEndpoint";
-var isHttpApiEndpoint = (u) => hasProperty(u, TypeId66);
+var TypeId67 = "~effect/http-api/HttpApiEndpoint";
+var isHttpApiEndpoint = (u) => hasProperty(u, TypeId67);
 function getPayloadSchemas(endpoint) {
   const result6 = [];
   for (const {
@@ -45762,7 +47492,7 @@ function getErrorSchemas(endpoint) {
   return Array.from(schemas);
 }
 var Proto19 = {
-  [TypeId66]: TypeId66,
+  [TypeId67]: TypeId67,
   pipe() {
     return pipeArguments(this, arguments);
   },
@@ -45810,7 +47540,7 @@ function makeProto2(options3) {
   Object.setPrototypeOf(HttpApiEndpoint, Proto19);
   return Object.assign(HttpApiEndpoint, options3);
 }
-var make59 = (method) => (identifier2, path, options3) => {
+var make63 = (method) => (identifier2, path, options3) => {
   const disableCodecs = options3?.disableCodecs ?? false;
   const transformStringTree = disableCodecs ? identity : toCodecStringTree2;
   return makeProto2({
@@ -45828,12 +47558,12 @@ var make59 = (method) => (identifier2, path, options3) => {
     disableCodecs
   });
 };
-function ensureStruct(params, transform6) {
-  if (params === undefined)
+function ensureStruct(params2, transform6) {
+  if (params2 === undefined)
     return;
-  if (isSchema(params))
-    return transform6(params);
-  return transform6(Struct4(params));
+  if (isSchema(params2))
+    return transform6(params2);
+  return transform6(Struct4(params2));
 }
 function getPayload(payload, method, disableCodecs) {
   const result6 = new Map;
@@ -46059,20 +47789,20 @@ function transformPayload(schema2, method) {
       return schema2;
   }
 }
-var get17 = /* @__PURE__ */ make59("GET");
-var query3 = /* @__PURE__ */ make59("QUERY");
-var post3 = /* @__PURE__ */ make59("POST");
-var put3 = /* @__PURE__ */ make59("PUT");
-var patch3 = /* @__PURE__ */ make59("PATCH");
-var del3 = /* @__PURE__ */ make59("DELETE");
-var head6 = /* @__PURE__ */ make59("HEAD");
-var options3 = /* @__PURE__ */ make59("OPTIONS");
+var get17 = /* @__PURE__ */ make63("GET");
+var query3 = /* @__PURE__ */ make63("QUERY");
+var post3 = /* @__PURE__ */ make63("POST");
+var put3 = /* @__PURE__ */ make63("PUT");
+var patch3 = /* @__PURE__ */ make63("PATCH");
+var del3 = /* @__PURE__ */ make63("DELETE");
+var head6 = /* @__PURE__ */ make63("HEAD");
+var options3 = /* @__PURE__ */ make63("OPTIONS");
 
 // ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/http-api/HttpApi.js
-var TypeId67 = "~effect/http-api/HttpApi";
-var isHttpApi = (u) => hasProperty(u, TypeId67);
+var TypeId68 = "~effect/http-api/HttpApi";
+var isHttpApi = (u) => hasProperty(u, TypeId68);
 var Proto20 = {
-  [TypeId67]: TypeId67,
+  [TypeId68]: TypeId68,
   pipe() {
     return pipeArguments(this, arguments);
   },
@@ -46136,7 +47866,7 @@ var makeProto3 = (options4) => {
   Object.setPrototypeOf(HttpApi, Proto20);
   return Object.assign(HttpApi, options4);
 };
-var make60 = (identifier2) => makeProto3({
+var make64 = (identifier2) => makeProto3({
   identifier: identifier2,
   groups: {},
   annotations: empty()
@@ -46169,9 +47899,9 @@ var reflect = (self, options4) => {
 };
 var extractResponseContent = (schemas, getStatus) => {
   const map20 = new Map;
-  schemas.forEach(add5);
+  schemas.forEach(add6);
   return map20;
-  function add5(schema2) {
+  function add6(schema2) {
     const body = isWithHeaders(schema2) ? schema2.schema : schema2;
     if (isStreamSchema(body))
       return;
@@ -46225,7 +47955,7 @@ __export(exports_HttpApiClient, {
   urlBuilder: () => urlBuilder,
   makeWith: () => makeWith3,
   makeClient: () => makeClient,
-  make: () => make61,
+  make: () => make65,
   group: () => group3,
   endpoint: () => endpoint
 });
@@ -46325,8 +48055,8 @@ var makeClient = (api, options4) => gen4(function* () {
         let httpRequest = make51(endpoint.method)(endpoint.path);
         if (request3 !== undefined) {
           if (encodeParams !== undefined) {
-            const params = yield* encodeParams(request3.params);
-            httpRequest = setUrl(httpRequest, makeUrl(params));
+            const params2 = yield* encodeParams(request3.params);
+            httpRequest = setUrl(httpRequest, makeUrl(params2));
           }
           if (encodePayload !== undefined) {
             if (hasBody(endpoint.method)) {
@@ -46365,7 +48095,7 @@ var makeClient = (api, options4) => gen4(function* () {
     }
   });
 });
-var make61 = (api, options4) => flatMap6(HttpClient, (httpClient) => makeWith3(api, {
+var make65 = (api, options4) => flatMap6(HttpClient, (httpClient) => makeWith3(api, {
   ...options4,
   httpClient: options4?.transformClient ? options4.transformClient(httpClient) : httpClient
 }));
@@ -46440,8 +48170,8 @@ var urlBuilder = (api, options4) => {
       const encodeParams = endpoint2.params === undefined ? undefined : encodeSync2(endpoint2.params, parseOptions.params);
       const encodeQuery = endpoint2.query === undefined ? undefined : encodeSync2(endpoint2.query, parseOptions.query);
       const endpointBuilder = (request3) => {
-        const params = request3?.params;
-        const path = params === undefined ? endpoint2.path : makeUrl(encodeParams === undefined ? params : encodeParams(params));
+        const params2 = request3?.params;
+        const path = params2 === undefined ? endpoint2.path : makeUrl(encodeParams === undefined ? params2 : encodeParams(params2));
         const queryInput = request3?.query === undefined ? undefined : encodeQuery === undefined ? request3.query : encodeQuery(request3.query);
         const urlParams3 = queryInput === undefined ? empty14 : fromInput4(queryInput);
         if (options4?.baseUrl === undefined) {
@@ -46467,12 +48197,12 @@ var compilePath = (path, schema2) => {
     return (_) => path;
   }
   const paramNames = getParamNames(schema2);
-  return (params) => {
+  return (params2) => {
     return path.replace(paramsRegExp, (match11, slash, key, optional6) => {
       if (paramNames !== undefined && !paramNames.has(key)) {
         return match11;
       }
-      const value5 = params[key];
+      const value5 = params2[key];
       if (value5 === undefined) {
         if (optional6 !== undefined) {
           return "";
@@ -46767,13 +48497,13 @@ function getEncodePayloadSchemaFromBody(schema2, method) {
 // ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/http-api/HttpApiGroup.js
 var exports_HttpApiGroup = {};
 __export(exports_HttpApiGroup, {
-  make: () => make62,
+  make: () => make66,
   isHttpApiGroup: () => isHttpApiGroup
 });
-var TypeId68 = "~effect/http-api/HttpApiGroup";
-var isHttpApiGroup = (u) => hasProperty(u, TypeId68);
+var TypeId69 = "~effect/http-api/HttpApiGroup";
+var isHttpApiGroup = (u) => hasProperty(u, TypeId69);
 var Proto21 = {
-  [TypeId68]: TypeId68,
+  [TypeId69]: TypeId69,
   add(...toAdd) {
     const endpoints = {
       ...this.endpoints
@@ -46838,7 +48568,7 @@ var makeProto4 = (options4) => {
   HttpApiGroup.key = `effect/http-api/HttpApiGroup/${options4.identifier}`;
   return Object.assign(HttpApiGroup, options4);
 };
-var make62 = (identifier2, options4) => makeProto4({
+var make66 = (identifier2, options4) => makeProto4({
   identifier: identifier2,
   topLevel: options4?.topLevel ?? false,
   endpoints: {},
@@ -46884,7 +48614,7 @@ class HttpApiSchemaError extends (/* @__PURE__ */ TaggedClass("HttpApiSchemaErro
 }
 
 // ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/http-api/HttpApiMiddleware.js
-var TypeId69 = "~effect/http-api/HttpApiMiddleware";
+var TypeId70 = "~effect/http-api/HttpApiMiddleware";
 var SecurityTypeId = "~effect/http-api/HttpApiMiddleware/Security";
 var isSecurity = (u) => hasProperty(u, SecurityTypeId);
 var Service2 = () => (id2, options4) => {
@@ -46904,7 +48634,7 @@ var Service2 = () => (id2, options4) => {
       return creationError?.stack;
     }
   });
-  self[TypeId69] = TypeId69;
+  self[TypeId70] = TypeId70;
   self.error = getError(options4?.error);
   self.requiredForClient = options4?.requiredForClient ?? false;
   if (options4?.security !== undefined) {
@@ -46937,9 +48667,9 @@ __export(exports_HttpApiSecurity, {
   annotateMerge: () => annotateMerge2,
   annotate: () => annotate6
 });
-var TypeId70 = "~effect/http-api/HttpApiSecurity";
+var TypeId71 = "~effect/http-api/HttpApiSecurity";
 var Proto22 = {
-  [TypeId70]: TypeId70,
+  [TypeId71]: TypeId71,
   pipe() {
     return pipeArguments(this, arguments);
   }
@@ -47751,7 +49481,7 @@ var exports_SqlClient = {};
 __export(exports_SqlClient, {
   makeWithTransaction: () => makeWithTransaction,
   makeSqliteAcquirers: () => makeSqliteAcquirers,
-  make: () => make64,
+  make: () => make68,
   TransactionConnection: () => TransactionConnection,
   SqlClient: () => SqlClient,
   SafeIntegers: () => SafeIntegers
@@ -47761,7 +49491,7 @@ __export(exports_SqlClient, {
 var Reactivity = /* @__PURE__ */ Service("effect/reactivity/Reactivity");
 
 // ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/sql/SqlError.js
-var TypeId71 = "~effect/sql/SqlError";
+var TypeId72 = "~effect/sql/SqlError";
 var ReasonTypeId2 = "~effect/sql/SqlError/Reason";
 var ReasonFields = {
   cause: /* @__PURE__ */ Defect(),
@@ -47854,7 +49584,7 @@ var SqlErrorReason = /* @__PURE__ */ Union2([ConnectionError, AuthenticationErro
 class SqlError extends (/* @__PURE__ */ TaggedError3("effect/sql/SqlError")("SqlError", {
   reason: SqlErrorReason
 })) {
-  [TypeId71] = TypeId71;
+  [TypeId72] = TypeId72;
   cause = this.reason;
   get message() {
     return this.reason.message || this.reason._tag;
@@ -47877,10 +49607,10 @@ var SpanPropagationEnabled = /* @__PURE__ */ Reference("effect/sql/SpanPropagati
   defaultValue: () => false
 });
 var isFragment = (u) => hasProperty(u, FragmentTypeId);
-var literal = (value5, params) => ({
+var literal = (value5, params2) => ({
   _tag: "Literal",
   value: value5,
-  params
+  params: params2
 });
 var identifier2 = (value5) => ({
   _tag: "Identifier",
@@ -47926,7 +49656,7 @@ var recordUpdateHelperSingle = (value5, omit4) => Object.assign(Object.create(Re
   omit: omit4,
   returningIdentifier: undefined
 });
-var make63 = (acquirer, compiler2, spanAttributes, transformRows, borrower) => {
+var make67 = (acquirer, compiler2, spanAttributes, transformRows, borrower) => {
   const cache2 = transformRows === undefined ? constructorCache.noTransforms : constructorCache.transforms;
   if (cache2.has(acquirer)) {
     return cache2.get(acquirer);
@@ -47939,8 +49669,8 @@ var make63 = (acquirer, compiler2, spanAttributes, transformRows, borrower) => {
     }
     throw "absurd";
   }, {
-    unsafe(sql, params) {
-      return makeUnsafe11([literal(sql, params)], acquirer, compiler2, spanAttributes, transformRows, borrower);
+    unsafe(sql, params2) {
+      return makeUnsafe11([literal(sql, params2)], acquirer, compiler2, spanAttributes, transformRows, borrower);
     },
     literal(sql) {
       return fragment([literal(sql)]);
@@ -48077,46 +49807,46 @@ var StatementProto = {
   },
   withConnectionSpan(operation, f, withoutTransform, span3) {
     return withStatement(this, span3, (statement2, fiber3) => {
-      const [sql, params] = statement2.compile(withoutTransform);
+      const [sql, params2] = statement2.compile(withoutTransform);
       for (const [key, value5] of this.spanAttributes) {
         span3.attribute(key, value5);
       }
       span3.attribute(ATTR_SQL_METHOD, operation);
       span3.attribute(ATTR_DB_QUERY_TEXT, sql);
-      const execute2 = this.borrower === undefined ? scoped2(flatMap6(this.acquirer, (_) => f(_, sql, params))) : this.borrower((connection) => f(connection, sql, params));
+      const execute2 = this.borrower === undefined ? scoped2(flatMap6(this.acquirer, (_) => f(_, sql, params2))) : this.borrower((connection) => f(connection, sql, params2));
       return fiber3.cache.tracerEnabled && fiber3.getRef(SpanPropagationEnabled) ? provideService2(execute2, ParentSpan, span3) : execute2;
     });
   },
   get withoutTransform() {
-    return this.withConnection("executeWithoutTransform", (connection, sql, params) => connection.execute(sql, params, undefined), true);
+    return this.withConnection("executeWithoutTransform", (connection, sql, params2) => connection.execute(sql, params2, undefined), true);
   },
   get raw() {
-    return this.withConnection("executeRaw", (connection, sql, params) => connection.executeRaw(sql, params), true);
+    return this.withConnection("executeRaw", (connection, sql, params2) => connection.executeRaw(sql, params2), true);
   },
   get stream() {
     const self = this;
     return unwrap4(flatMap6(makeSpanScoped2(spanName(self.spanAttributes), {
       kind: "client"
     }), (span3) => withStatement(self, span3, (statement2, fiber3) => {
-      const [sql, params] = statement2.compile();
+      const [sql, params2] = statement2.compile();
       for (const [key, value5] of self.spanAttributes) {
         span3.attribute(key, value5);
       }
       span3.attribute(ATTR_SQL_METHOD, "executeStream");
       span3.attribute(ATTR_DB_QUERY_TEXT, sql);
-      const acquire = map9(self.acquirer, (_) => _.executeStream(sql, params, self.transformRows));
+      const acquire = map9(self.acquirer, (_) => _.executeStream(sql, params2, self.transformRows));
       return fiber3.cache.tracerEnabled && fiber3.getRef(SpanPropagationEnabled) ? succeed6(provideService4(unwrap4(acquire), ParentSpan, span3)) : acquire;
     })));
   },
   get values() {
-    return this.withConnection("executeValues", (connection, sql, params) => connection.executeValues(sql, params));
+    return this.withConnection("executeValues", (connection, sql, params2) => connection.executeValues(sql, params2));
   },
   get valuesUnprepared() {
-    return this.withConnection("executeValuesUnprepared", (connection, sql, params) => connection.executeValuesUnprepared(sql, params));
+    return this.withConnection("executeValuesUnprepared", (connection, sql, params2) => connection.executeValuesUnprepared(sql, params2));
   },
   get unprepared() {
     const self = this;
-    return self.withConnection("executeUnprepared", (connection, sql, params) => connection.executeUnprepared(sql, params, self.transformRows));
+    return self.withConnection("executeUnprepared", (connection, sql, params2) => connection.executeUnprepared(sql, params2, self.transformRows));
   },
   .../* @__PURE__ */ Prototype2({
     label: "Statement",
@@ -48126,19 +49856,19 @@ var StatementProto = {
       });
       const clock = fiber3.getRef(Clock);
       const timingEnabled = fiber3.getRef(TracerTimingEnabled2);
-      return onExit2(this.withConnectionSpan("execute", (connection, sql, params) => connection.execute(sql, params, this.transformRows), false, span3), (exit3) => endSpan(span3, exit3, clock, timingEnabled));
+      return onExit2(this.withConnectionSpan("execute", (connection, sql, params2) => connection.execute(sql, params2, this.transformRows), false, span3), (exit3) => endSpan(span3, exit3, clock, timingEnabled));
     }
   }),
   compile(withoutTransform) {
     return this.compiler.compile(this, withoutTransform ?? false);
   },
   toJSON() {
-    const [sql, params] = this.compile();
+    const [sql, params2] = this.compile();
     return {
       _id: "Statement",
       segments: this.segments,
       sql,
-      params
+      params: params2
     };
   }
 };
@@ -48147,7 +49877,7 @@ var withStatement = (self, span3, f) => withFiber2((fiber3) => {
   if (transform6 === undefined) {
     return f(self, fiber3);
   }
-  return flatMap6(transform6(self, make63(self.acquirer, self.compiler, self.spanAttributes, self.transformRows, self.borrower), fiber3, span3), (statement2) => f(statement2, fiber3));
+  return flatMap6(transform6(self, make67(self.acquirer, self.compiler, self.spanAttributes, self.transformRows, self.borrower), fiber3, span3), (statement2) => f(statement2, fiber3));
 });
 var isSegment = (u) => {
   if (!hasProperty(u, "_tag")) {
@@ -48184,11 +49914,11 @@ function in_() {
 var neverFragment = /* @__PURE__ */ fragment([/* @__PURE__ */ literal("1=0")]);
 
 // ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/sql/SqlClient.js
-var TypeId72 = "~effect/sql/SqlClient";
+var TypeId73 = "~effect/sql/SqlClient";
 var SqlClient = /* @__PURE__ */ Service("effect/sql/SqlClient");
 var clientIdCounter = 0;
 var transactionSemaphoreIdCounter = 0;
-var make64 = /* @__PURE__ */ fnUntraced2(function* (options4) {
+var make68 = /* @__PURE__ */ fnUntraced2(function* (options4) {
   const transactionService = options4.transactionService ?? TransactionConnection(clientIdCounter++);
   const getConnection = flatMap6(serviceOption2(transactionService), match({
     onNone: () => options4.acquirer,
@@ -48219,8 +49949,8 @@ var make64 = /* @__PURE__ */ fnUntraced2(function* (options4) {
     onNone: () => options4.borrower(f),
     onSome: ([conn]) => f(conn)
   }));
-  const client = Object.assign(make63(getConnection, options4.compiler, options4.spanAttributes, options4.transformRows, borrower), {
-    [TypeId72]: TypeId72,
+  const client = Object.assign(make67(getConnection, options4.compiler, options4.spanAttributes, options4.transformRows, borrower), {
+    [TypeId73]: TypeId73,
     safe: undefined,
     withTransaction,
     transactionService,
@@ -48229,7 +49959,7 @@ var make64 = /* @__PURE__ */ fnUntraced2(function* (options4) {
       if (options4.transformRows === undefined) {
         return this;
       }
-      const statement2 = make63(getConnection, options4.compiler.withoutTransform, options4.spanAttributes, undefined, borrower);
+      const statement2 = make67(getConnection, options4.compiler.withoutTransform, options4.spanAttributes, undefined, borrower);
       const client2 = Object.assign(statement2, {
         ...this,
         ...statement2
@@ -49229,6 +50959,75 @@ class Device extends exports_HttpApiGroup.make("device").add(exports_HttpApiEndp
 
 class Api extends exports_HttpApi.make("auth").add(Session).add(Device).prefix("/api/auth") {
 }
+// ../core/src/Api/CliVersion.ts
+var exports_CliVersion = {};
+__export(exports_CliVersion, {
+  supported: () => supported,
+  standing: () => standing,
+  refuses: () => refuses,
+  minimumHeader: () => minimumHeader,
+  minimum: () => minimum,
+  layer: () => layer16,
+  header: () => header,
+  Version: () => Version4,
+  Outdated: () => Outdated
+});
+
+// ../core/src/Semver.ts
+var exports_Semver = {};
+__export(exports_Semver, {
+  precedence: () => precedence,
+  parse: () => parse7,
+  isRelease: () => isRelease
+});
+var SEMVER = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z.-]+)?$/;
+var parse7 = (version) => exports_Option.map(exports_Option.fromNullishOr(SEMVER.exec(version)), ([, major, minor, patch4, pre]) => ({
+  major: Number(major),
+  minor: Number(minor),
+  patch: Number(patch4),
+  pre: pre?.split(".").map((identifier3) => /^\d+$/.test(identifier3) ? Number(identifier3) : identifier3)
+}));
+var identifiers = exports_Order.make((self, that) => exports_Predicate.isNumber(self) && exports_Predicate.isNumber(that) ? exports_Order.Number(self, that) : exports_Predicate.isNumber(self) ? -1 : exports_Predicate.isNumber(that) ? 1 : exports_Order.String(self, that));
+var preReleases = exports_Order.make((self, that) => self === undefined ? 1 : that === undefined ? -1 : exports_Order.Array(identifiers)(self, that));
+var precedence = exports_Order.Struct({
+  major: exports_Order.Number,
+  minor: exports_Order.Number,
+  patch: exports_Order.Number,
+  pre: preReleases
+});
+var isRelease = (version) => version.pre === undefined;
+
+// ../core/src/Api/CliVersion.ts
+var header = "ambral-cli-version";
+var minimumHeader = "ambral-cli-minimum";
+var Version4 = exports_Schema.String.check(exports_Schema.makeFilter((version) => exports_Option.isSome(parse7(version)) || "a semantic version")).pipe(exports_Schema.brand("CliVersion")).annotate({ identifier: "CliVersion" });
+var minimum = undefined;
+
+class Outdated extends exports_Schema.TaggedError()("CliOutdated", {
+  minimum: Version4
+}, { httpApiStatus: 426 }) {
+}
+var isOlder = (version, than) => exports_Option.exists(parse7(than), (oldest) => exports_Order.isLessThan(precedence)(version, oldest));
+var refuses = (oldest, sent) => oldest !== undefined && sent !== undefined && exports_Option.exists(parse7(sent), (version) => isOlder(version, oldest));
+var releases = (published) => published.flatMap((name) => exports_Option.match(exports_Option.filter(parse7(name), isRelease), {
+  onNone: () => [],
+  onSome: (version) => [{ name: Version4.make(name), version }]
+})).toSorted((self, that) => precedence(self.version, that.version));
+var supported = (oldest, published) => releases(published).filter(({ version }) => oldest === undefined || !isOlder(version, oldest)).map(({ name }) => name);
+var standing = (version, published) => {
+  const newest = releases(published).at(-1);
+  const order = newest === undefined ? 1 : precedence(exports_Option.getOrThrow(parse7(version)), newest.version);
+  return order > 0 ? "unreleased" : order === 0 ? "released" : "behind";
+};
+var layer16 = (oldest) => exports_HttpRouter.middleware()((httpEffect) => exports_Effect.gen(function* () {
+  const request3 = yield* exports_HttpServerRequest.HttpServerRequest;
+  if (oldest === undefined || !refuses(oldest, request3.headers[header]))
+    return yield* httpEffect;
+  return yield* exports_HttpServerResponse.schemaJson(Outdated)(new Outdated({ minimum: oldest }), {
+    status: 426,
+    headers: { [minimumHeader]: oldest }
+  }).pipe(exports_Effect.orDie);
+})).layer;
 // ../core/src/ApiKey/ApiKey.ts
 var exports_ApiKey = {};
 __export(exports_ApiKey, {
@@ -49284,7 +51083,7 @@ var rotrBH = (h, l, s) => h << 64 - s | l >>> s - 32;
 var rotrBL = (h, l, s) => h >>> s - 32 | l << 64 - s;
 var rotr32H = (_h, l) => l;
 var rotr32L = (h, _l) => h;
-function add5(Ah, Al, Bh, Bl) {
+function add6(Ah, Al, Bh, Bl) {
   const l = (Al >>> 0) + (Bl >>> 0);
   return { h: Ah + Bh + (l / 2 ** 32 | 0) | 0, l: l | 0 };
 }
@@ -49683,7 +51482,7 @@ __export(exports_KeyValueStore, {
   toSchemaStore: () => toSchemaStore,
   prefix: () => prefix3,
   makeStringOnly: () => makeStringOnly,
-  make: () => make65,
+  make: () => make69,
   layerStorage: () => layerStorage,
   layerSql: () => layerSql,
   layerMemory: () => layerMemory,
@@ -49691,15 +51490,15 @@ __export(exports_KeyValueStore, {
   KeyValueStoreError: () => KeyValueStoreError,
   KeyValueStore: () => KeyValueStore
 });
-var TypeId73 = "~effect/persistence/KeyValueStore";
+var TypeId74 = "~effect/persistence/KeyValueStore";
 var ErrorTypeId = "~effect/persistence/KeyValueStore/KeyValueStoreError";
 
 class KeyValueStoreError extends (/* @__PURE__ */ TaggedError2("KeyValueStoreError")) {
   [ErrorTypeId] = ErrorTypeId;
 }
 var KeyValueStore = /* @__PURE__ */ Service("effect/persistence/KeyValueStore");
-var make65 = (options4) => KeyValueStore.of({
-  [TypeId73]: TypeId73,
+var make69 = (options4) => KeyValueStore.of({
+  [TypeId74]: TypeId74,
   has: (key) => map9(options4.get(key), isNotUndefined),
   isEmpty: map9(options4.size, (size8) => size8 === 0),
   modify: (key, f) => flatMap6(options4.get(key), (o) => {
@@ -49720,7 +51519,7 @@ var make65 = (options4) => KeyValueStore.of({
 });
 var makeStringOnly = (options4) => {
   const encoder6 = new TextEncoder;
-  return make65({
+  return make69({
     ...options4,
     getUint8Array: (key) => options4.get(key).pipe(map9(map20((value5) => match2(decode2(value5), {
       onFailure: () => encoder6.encode(value5),
@@ -49742,7 +51541,7 @@ var prefix3 = /* @__PURE__ */ dual(2, (self, prefix4) => ({
 var layerMemory = /* @__PURE__ */ sync2(KeyValueStore)(() => {
   const store = new Map;
   const encoder6 = new TextEncoder;
-  return make65({
+  return make69({
     get: (key) => sync3(() => {
       const value5 = store.get(key);
       return value5 === undefined ? undefined : typeof value5 === "string" ? value5 : encode2(value5);
@@ -49770,7 +51569,7 @@ var layerFileSystem = (directory) => effect(KeyValueStore)(gen4(function* () {
       recursive: true
     });
   }
-  return make65({
+  return make69({
     get: (key) => withKeyPath("get", key, (path2) => catchTag3(fs.readFileString(path2), "PlatformError", (cause) => cause.reason._tag === "NotFound" ? undefined_2 : fail6(new KeyValueStoreError({
       method: "get",
       key,
@@ -49880,7 +51679,7 @@ var layerSql = (options4 = {}) => effect(KeyValueStore)(gen4(function* () {
   const decoder4 = new TextDecoder;
   const ValueTypeString = 0;
   const ValueTypeUint8Array = 1;
-  return make65({
+  return make69({
     get: (key) => sql`SELECT value, value_type FROM ${table2} WHERE id = ${key}`.pipe(mapError4((cause) => new KeyValueStoreError({
       method: "get",
       key,
@@ -50738,7 +52537,7 @@ function G1b(a, b, c, d, msg, x) {
   let xh = Dh ^ Ah, xl = Dl ^ Al;
   Dh = rotr32H(xh, xl);
   Dl = rotr32L(xh, xl);
-  ({ h: Ch, l: Cl } = add5(Ch, Cl, Dh, Dl));
+  ({ h: Ch, l: Cl } = add6(Ch, Cl, Dh, Dl));
   xh = Bh ^ Ch;
   xl = Bl ^ Cl;
   Bh = rotrSH(xh, xl, 24);
@@ -50764,7 +52563,7 @@ function G2b(a, b, c, d, msg, x) {
   let xh = Dh ^ Ah, xl = Dl ^ Al;
   Dh = rotrSH(xh, xl, 16);
   Dl = rotrSL(xh, xl, 16);
-  ({ h: Ch, l: Cl } = add5(Ch, Cl, Dh, Dl));
+  ({ h: Ch, l: Cl } = add6(Ch, Cl, Dh, Dl));
   xh = Bh ^ Ch;
   xl = Bl ^ Cl;
   Bh = rotrBH(xh, xl, 63);
@@ -52733,7 +54532,7 @@ var exports_Workload = {};
 __export(exports_Workload, {
   routeOf: () => routeOf,
   movesRoute: () => movesRoute,
-  make: () => make66,
+  make: () => make70,
   list: () => list5,
   get: () => get23,
   create: () => create,
@@ -53151,7 +54950,7 @@ var applyChange = (pool, change2) => exports_Match.valueTags(change2, {
   }
 });
 var movesRoute = (before, after) => before.primary !== after.primary || before.baseline !== after.baseline;
-var make66 = (org, input, id2) => ({
+var make70 = (org, input, id2) => ({
   id: id2,
   org,
   name: input.name,
@@ -53225,7 +55024,7 @@ var republish = exports_Effect.fnUntraced(function* (org, name) {
 var create = exports_Effect.fn("Workload.create")(function* (org, input, actor) {
   const sql = yield* exports_SqlClient.SqlClient;
   const routes = yield* RoutePublisher;
-  const workload = make66(org, input, WorkloadId.make(yield* uuid));
+  const workload = make70(org, input, WorkloadId.make(yield* uuid));
   const changeId = ChangeId.make(yield* uuid);
   yield* exports_Effect.annotateCurrentSpan({ org, workload: input.name, workloadId: workload.id });
   const at = yield* now3;
@@ -53452,7 +55251,7 @@ var generate6 = exports_Effect.fn("ApiKey.generate")(function* (kind, deployed)
 var start2 = (key2) => Start.make(key2.slice(0, key2.length - KEY_LENGTH + START_LENGTH));
 var decodePlaintext = exports_Schema.decodeUnknownResult(Plaintext2);
 var fromAuthorization = (authorization) => {
-  const match11 = exports_Option.flatMapNullishOr(authorization, (header) => /^Bearer[ \t]+(\S+)[ \t]*$/i.exec(header)?.[1]);
+  const match11 = exports_Option.flatMapNullishOr(authorization, (header2) => /^Bearer[ \t]+(\S+)[ \t]*$/i.exec(header2)?.[1]);
   if (exports_Option.isNone(match11))
     return exports_Result.fail("missing");
   return exports_Result.mapError(decodePlaintext(match11.value), () => "invalid");
@@ -53796,7 +55595,7 @@ var JudgeCall = exports_Schema.Struct({
   request: JudgeRequest,
   response: JudgeResponse
 }).annotate({ identifier: "JudgeCall" });
-var make67 = (name, model, messages, completion, parsed) => {
+var make71 = (name, model, messages, completion, parsed) => {
   const usage = completion.call.usage;
   return {
     name,
@@ -54076,13 +55875,13 @@ var summarize = (scores) => {
 };
 
 // ../../node_modules/.bun/effect@4.0.3/node_modules/effect/dist/ai/Tool.js
-var TypeId74 = "~effect/ai/Tool";
+var TypeId75 = "~effect/ai/Tool";
 var ProviderDefinedTypeId = "~effect/ai/Tool/ProviderDefined";
 var DynamicTypeId = "~effect/ai/Tool/Dynamic";
 var isProviderDefined = (u) => hasProperty(u, ProviderDefinedTypeId);
 var clone = (self, overrides) => Object.assign(Object.create(Object.getPrototypeOf(self)), self, overrides);
 var Proto23 = {
-  [TypeId74]: {
+  [TypeId75]: {
     _Requirements: identity
   },
   pipe() {
@@ -54650,12 +56449,12 @@ function mergeLowerBound(schema2, key3, value5) {
       schema2[key3] = value5;
     return;
   }
-  const minimum = typeof schema2.minimum === "number" ? schema2.minimum : undefined;
+  const minimum2 = typeof schema2.minimum === "number" ? schema2.minimum : undefined;
   const exclusiveMinimum = typeof schema2.exclusiveMinimum === "number" ? schema2.exclusiveMinimum : undefined;
   let current;
-  if (minimum !== undefined)
+  if (minimum2 !== undefined)
     current = {
-      value: minimum,
+      value: minimum2,
       exclusive: false
     };
   if (exclusiveMinimum !== undefined && (current === undefined || exclusiveMinimum >= current.value)) {
@@ -55325,7 +57124,7 @@ var verdictOf = exports_Effect.fnUntraced(function* (org, run6, name, model, ver
   const failed = (reason) => (cause) => new VerifierError({ reason, scorer: name, cause });
   const completion = yield* produce(model, prompt, org);
   const read5 = verdicts.read(completion.reply.content ?? "");
-  const call = yield* write3(org, run6, make67(name, model.id, prompt.messages, completion, exports_Result.getOrUndefined(read5)?.answer ?? null)).pipe(exports_Effect.mapError(failed("Unavailable")));
+  const call = yield* write3(org, run6, make71(name, model.id, prompt.messages, completion, exports_Result.getOrUndefined(read5)?.answer ?? null)).pipe(exports_Effect.mapError(failed("Unavailable")));
   const { recorded } = yield* exports_Effect.fromResult(read5).pipe(exports_Effect.mapError(failed("Failed")));
   return { recorded, call };
 });
@@ -55383,7 +57182,7 @@ var trajectoryJudge = exports_Layer.effect(Judge, exports_Effect.gen(function* (
     }, exports_Effect.provideContext(services))
   });
 }));
-var layer15 = exports_Layer.merge(verifiers, trajectoryJudge);
+var layer17 = exports_Layer.merge(verifiers, trajectoryJudge);
 
 // ../core/src/Scoring/ReplayEnv.ts
 var SAMPLE_EXPECTED = `{ type: "sample", k: n }`;
@@ -55646,15 +57445,15 @@ var uncounted = (config) => {
   const scoredBy = exports_Record.keys(EpisodeScorerConfigs.fields).filter((name) => rewards[name] !== null);
   if (scoredBy.length > 0 && rewards.replies === null) {
     const by = `the trace scores only by \`episode.rewards\` (${scoredBy.map((name) => `\`${name}\``).join(", ")})`;
-    const add6 = metrics.replies === null ? "add `episode.rewards.replies` to count it" : "move `replies` from `episode.metrics` to `episode.rewards` to count it";
+    const add7 = metrics.replies === null ? "add `episode.rewards.replies` to count it" : "move `replies` from `episode.metrics` to `episode.rewards` to count it";
     return [
       ...scorers.map(({ movesToMetrics, path }) => ({
         path,
-        message: `Counts toward each reply's score, but ${by}; ${add6}` + (movesToMetrics ? ", or move it to `metrics` to record it." : ".")
+        message: `Counts toward each reply's score, but ${by}; ${add7}` + (movesToMetrics ? ", or move it to `metrics` to record it." : ".")
       })),
       ...config.required.map((_, i) => ({
         path: ["required", i],
-        message: `Zeroes the score of a reply where it fails, but ${by}; ${add6}.`
+        message: `Zeroes the score of a reply where it fails, but ${by}; ${add7}.`
       }))
     ];
   }
@@ -58115,7 +59914,7 @@ var PUBLIC_APP = "https://app.ambral.ai";
 
 class Target extends exports_Context.Service()("ambral/Target") {
 }
-var layer16 = exports_Layer.effect(Target, exports_Effect.gen(function* () {
+var layer18 = exports_Layer.effect(Target, exports_Effect.gen(function* () {
   const url = yield* exports_Config.URL("AMBRAL_URL").pipe(exports_Config.withDefault(new URL(PUBLIC_APP)));
   return Target.of({ url: new URL(url.origin) });
 }));
@@ -58147,7 +59946,7 @@ class Credentials extends exports_Context.Service()("ambral/Login/Credentials")
 }
 var DIRECTORY_MODE = 448;
 var FILE_MODE = 384;
-var layer17 = exports_Layer.effect(Credentials, exports_Effect.gen(function* () {
+var layer19 = exports_Layer.effect(Credentials, exports_Effect.gen(function* () {
   const fs = yield* exports_FileSystem.FileSystem;
   const path = yield* exports_Path.Path;
   const { url } = yield* Target;
@@ -58183,9 +59982,10 @@ class Ambral extends exports_Context.Service()("ambral/Ambral") {
 
 class SignIn2 extends exports_Context.Service()("ambral/SignIn") {
 }
+var versioned = exports_Effect.map(exports_Effect.service(exports_HttpClient.HttpClient), exports_HttpClient.mapRequest(exports_HttpClientRequest.setHeader(exports_CliVersion.header, package_default.version)));
 var as5 = exports_Effect.fn("Ambral.as")(function* (token) {
   const { url } = yield* Target;
-  const httpClient = exports_HttpClient.mapRequest(yield* exports_HttpClient.HttpClient, exports_HttpClientRequest.bearerToken(token));
+  const httpClient = exports_HttpClient.mapRequest(yield* versioned, exports_HttpClientRequest.bearerToken(token));
   const withBearer = exports_Effect.provideService(exports_HttpClient.HttpClient, httpClient);
   return Ambral.of({
     platform: yield* exports_HttpApiClient.make(exports_PlatformApi.Api, { baseUrl: url }).pipe(exports_Effect.provide(exports_Auth.layerClient), withBearer),
@@ -58197,10 +59997,10 @@ var signedIn = exports_Layer.effect(Ambral, exports_Effect.gen(function* () {
   if (token === undefined)
     return yield* new NotSignedIn({ address: (yield* Target).url.origin });
   return yield* as5(token);
-})).pipe(exports_Layer.provideMerge(layer17), exports_Layer.provideMerge(layer16));
+})).pipe(exports_Layer.provideMerge(layer19), exports_Layer.provideMerge(layer18));
 var signedOut = exports_Layer.effect(SignIn2, exports_Effect.gen(function* () {
   const { url } = yield* Target;
-  return (yield* exports_HttpApiClient.make(exports_AuthApi.Api, { baseUrl: url }).pipe(exports_Effect.provide(exports_Auth.layerClient))).device;
+  return (yield* exports_HttpApiClient.make(exports_AuthApi.Api, { baseUrl: url }).pipe(exports_Effect.provide(exports_Auth.layerClient), exports_Effect.provideService(exports_HttpClient.HttpClient, yield* versioned))).device;
 }));
 
 // src/Output.ts
@@ -58222,13 +60022,22 @@ var sessionEnded = (cause) => {
   const failure = exports_Cause.squash(cause);
   return exports_Schema.is(exports_Auth.Unauthorized)(failure) || exports_HttpClientError.isHttpClientError(failure) && failure.response?.status === 401;
 };
+var oldestServed = (cause) => {
+  const failure = exports_Cause.squash(cause);
+  return exports_HttpClientError.isHttpClientError(failure) && failure.response?.status === 426 ? exports_Schema.decodeOption(exports_CliVersion.Version)(failure.response.headers[exports_CliVersion.minimumHeader]) : exports_Option.none();
+};
 var renderFailure = (expected2, advise, cause, json6, address) => {
   const squashed = exports_Cause.squash(cause);
-  const failure = sessionEnded(cause) ? new NotSignedIn({ address }) : exports_Schema.is(expected2)(squashed) ? squashed : new Unexpected({
+  const oldest = oldestServed(cause);
+  const failure = sessionEnded(cause) ? new NotSignedIn({ address }) : exports_Option.isSome(oldest) ? new exports_CliVersion.Outdated({ minimum: oldest.value }) : exports_Schema.is(expected2)(squashed) ? squashed : new Unexpected({
     message: exports_Option.exists(exports_Cause.findErrorOption(cause), exports_Schema.isSchemaError) ? "The server answered in a form this CLI doesn't read. Update ambral." : exports_Predicate.isError(squashed) ? squashed.message : String(squashed)
   });
   const { message, remedy } = exports_Schema.is(expected2)(failure) ? advise(failure) : { message: failure.message, remedy: null };
-  const error2 = { ...exports_Schema.encodeSync(exports_Schema.Union([expected2, NotSignedIn, Unexpected]))(failure), message, remedy };
+  const error2 = {
+    ...exports_Schema.encodeSync(exports_Schema.Union([expected2, NotSignedIn, exports_CliVersion.Outdated, Unexpected]))(failure),
+    message,
+    remedy
+  };
   return json6 ? JSON.stringify({ error: error2 }, null, 2) : remedy === null ? message : `${message}
 ${remedy}`;
 };
@@ -58288,7 +60097,7 @@ var root = exports_Effect.gen(function* () {
   const working = (yield* exports_Path.Path).resolve(yield* WorkingDirectory);
   return (yield* rootFrom(working)) ?? working;
 });
-var layer18 = exports_Layer.effect(ProjectLink, exports_Effect.gen(function* () {
+var layer20 = exports_Layer.effect(ProjectLink, exports_Effect.gen(function* () {
   const fs = yield* exports_FileSystem.FileSystem;
   const path = yield* exports_Path.Path;
   const { url } = yield* Target;
@@ -58375,7 +60184,7 @@ var current = exports_Effect.gen(function* () {
   return yield* exports_Array.findFirst(all6, (membership) => membership.org === link4.org).pipe(exports_Effect.fromOption, exports_Effect.mapError(() => new NotLinked({ stale: link4.slug, memberships: all6 })));
 });
 var acting = exports_Effect.filterOrElse(current, exports_Predicate.isNotUndefined, () => exports_Effect.flatMap(memberships2, (all6) => exports_Effect.fail(new NotLinked({ memberships: all6 }))));
-var inProject = layer18.pipe(exports_Layer.provideMerge(signedIn));
+var inProject = layer20.pipe(exports_Layer.provideMerge(signedIn));
 var Listed = exports_Schema.Struct({ membership: exports_OrgAccess.Membership, linked: exports_Schema.Boolean });
 var listed3 = {
   schema: exports_Schema.Array(Listed),
@@ -58401,7 +60210,7 @@ var list11 = exports_Command.make("list", {}, () => exports_Effect.gen(function*
   const link4 = yield* (yield* ProjectLink).get;
   yield* print(listed3, all6.map((membership) => ({ membership, linked: membership.org === link4?.org })));
 })).pipe(exports_Command.provide(inProject), exports_Command.withDescription("List your orgs, with your role and each org's status"));
-var use = exports_Command.make("use", {
+var use2 = exports_Command.make("use", {
   slug: exports_Argument.String("slug").pipe(exports_Argument.withDescription("The org's slug, as `ambral orgs list` shows it"), exports_Argument.withSchema(exports_OrgAccess.Slug))
 }, ({ slug }) => exports_Effect.gen(function* () {
   const membership = yield* bySlug(slug);
@@ -58419,7 +60228,7 @@ var create4 = exports_Command.make("create", {
     project: unlinked ? yield* project2.set(exports_Struct.pick(membership, ["org", "slug"])) : undefined
   });
 })).pipe(exports_Command.provide(inProject), exports_Command.withDescription("Create an org you own; links this project to it if it isn't linked yet"));
-var orgs = exports_Command.make("orgs").pipe(exports_Command.withDescription("List your orgs, create one, and link this project to one"), exports_Command.withSubcommands([list11, use, create4]));
+var orgs = exports_Command.make("orgs").pipe(exports_Command.withDescription("List your orgs, create one, and link this project to one"), exports_Command.withSubcommands([list11, use2, create4]));
 
 // src/Keys/Keys.ts
 var listed4 = {
@@ -58514,7 +60323,7 @@ var SignedOut2 = {
   schema: exports_Schema.Struct({ address: exports_Schema.String }),
   text: ({ address }) => `Signed out of ${address}.`
 };
-var signingIn = exports_Layer.mergeAll(signedOut, layer17).pipe(exports_Layer.provideMerge(layer16));
+var signingIn = exports_Layer.mergeAll(signedOut, layer19).pipe(exports_Layer.provideMerge(layer18));
 var readable = exports_Effect.flatMap(Credentials, ({ get: get27 }) => get27.pipe(exports_Effect.catchIf((error2) => error2.reason === "unreadable", () => exports_Effect.succeed({}))));
 var start4 = exports_Effect.gen(function* () {
   const signIn = yield* SignIn2;
@@ -58848,8 +60657,8 @@ var warn2 = exports_Effect.fnUntraced(function* (config2) {
 });
 var toScore = (address) => "Set how it's scored: pick a preset from `ambral tasksets scoring preset`, write it to a file with " + "`ambral tasksets scoring preset <name> > <file>`, edit the file, then " + `\`ambral tasksets scoring set ${encodeAddress2(address)} --file <file>\`.`;
 var encodeConfig2 = exports_Schema.encodeSync(exports_Env.EnvConfig);
-var annotated = (header, config2) => [
-  ...header.map((line) => `# ${line}`),
+var annotated = (header2, config2) => [
+  ...header2.map((line) => `# ${line}`),
   "# Every key is explained above it; a key whose comment gives a default may be left out. Each judge's `model` is",
   "# one from `ambral models list`.",
   "#",
@@ -58861,7 +60670,7 @@ var listed6 = {
   text: (presets2) => [
     table2([
       ["PRESET", "USE IT WHEN"],
-      ...presets2.map(({ name, use: use2, judge }) => [name, judge ? `${use2} Takes --judge <model>.` : use2])
+      ...presets2.map(({ name, use: use3, judge }) => [name, judge ? `${use3} Takes --judge <model>.` : use3])
     ]),
     "",
     "Write one to a file to edit: `ambral tasksets scoring preset <name> > <file>`."
@@ -58931,11 +60740,11 @@ var set9 = exports_Command.make("set", {
   const config2 = yield* exports_Effect.fromResult(file3);
   const { platform: platform2 } = yield* Ambral;
   const { org } = yield* acting;
-  const params = { org, workload: taskset.workload, taskset: taskset.taskset };
+  const params2 = { org, workload: taskset.workload, taskset: taskset.taskset };
   if (check4)
-    yield* print(checked, yield* platform2.tasksets.checkScoring({ params, payload: config2 }));
+    yield* print(checked, yield* platform2.tasksets.checkScoring({ params: params2, payload: config2 }));
   else
-    yield* print(saved(taskset), yield* platform2.tasksets.putScoring({ params, payload: config2 }));
+    yield* print(saved(taskset), yield* platform2.tasksets.putScoring({ params: params2, payload: config2 }));
   yield* warn2(config2);
 })).pipe(exports_Command.provide(inProject), exports_Command.withDescription("Save a scoring config as a taskset's next version, after checking it. A config with mistakes prints each, at " + "its field, and saves nothing"), exports_Command.withExamples([
   {
@@ -59156,13 +60965,13 @@ var failedLines = ({ failed: failed2 }) => failed2.length === 0 ? [] : [
 ];
 var readoutText = (readout2) => {
   const { run: run7 } = readout2;
-  const header = `Run ${run7.id} · ${encodeAddress2(run7.taskset)} · ${scoringOf(run7)} · ${run7.status} · ` + progressOf(readout2);
+  const header2 = `Run ${run7.id} · ${encodeAddress2(run7.taskset)} · ${scoringOf(run7)} · ${run7.status} · ` + progressOf(readout2);
   if (run7.status === "running")
-    return `${header}
+    return `${header2}
 Read it again with \`ambral runs show ${run7.id}\`.`;
   const columns = columnsOf(readout2.subjects);
   return [
-    header,
+    header2,
     "",
     table2([
       ["", ...columns.map(({ subject }) => subjectName(subject))],
@@ -60250,24 +62059,9 @@ ${markdown}`;
 }, exports_Effect.orDie);
 var Stamped = exports_Schema.Struct({ metadata: exports_Schema.Struct({ version: exports_Schema.String }) });
 var versionOf = (text3) => partsOf(text3).pipe(exports_Option.flatMap(({ yaml }) => exports_Option.liftThrowable(exports_Yaml.parse)(yaml)), exports_Option.flatMap(exports_Schema.decodeUnknownOption(Stamped)), exports_Option.map(({ metadata }) => metadata.version));
-var SEMVER = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z.-]+)?$/;
-var semverOf = (version) => exports_Option.map(exports_Option.fromNullishOr(SEMVER.exec(version)), ([, major, minor, patch4, pre]) => ({
-  major: Number(major),
-  minor: Number(minor),
-  patch: Number(patch4),
-  pre: pre?.split(".").map((identifier3) => /^\d+$/.test(identifier3) ? Number(identifier3) : identifier3)
-}));
-var identifiers = exports_Order.make((self, that) => exports_Predicate.isNumber(self) && exports_Predicate.isNumber(that) ? exports_Order.Number(self, that) : exports_Predicate.isNumber(self) ? -1 : exports_Predicate.isNumber(that) ? 1 : exports_Order.String(self, that));
-var preReleases = exports_Order.make((self, that) => self === undefined ? 1 : that === undefined ? -1 : exports_Order.Array(identifiers)(self, that));
-var precedence = exports_Order.Struct({
-  major: exports_Order.Number,
-  minor: exports_Order.Number,
-  patch: exports_Order.Number,
-  pre: preReleases
-});
-var isStale = (text3, current2) => exports_Option.match(exports_Option.all([exports_Option.flatMap(versionOf(text3), semverOf), semverOf(current2)]), {
+var isStale = (text3, current2) => exports_Option.match(exports_Option.all([exports_Option.flatMap(versionOf(text3), exports_Semver.parse), exports_Semver.parse(current2)]), {
   onNone: () => false,
-  onSome: ([installed, running]) => exports_Order.isLessThan(precedence)(installed, running)
+  onSome: ([installed, running]) => exports_Order.isLessThan(exports_Semver.precedence)(installed, running)
 });
 var failures2 = {
   check: "Couldn't check for the folder",
@@ -60365,6 +62159,7 @@ var hint = exports_Layer.effectDiscard(exports_Effect.gen(function* () {
 // src/Remedies.ts
 var Failures = exports_Schema.Union([
   NotSignedIn,
+  exports_CliVersion.Outdated,
   CredentialsError,
   NoPendingSignIn,
   SignInDenied,
@@ -60439,6 +62234,10 @@ var branchOf2 = exports_Schema.encodeSync(exports_TraceReading.Ref);
 var subjectName2 = exports_Schema.encodeSync(exports_Run.Subject);
 var advise = (failure) => exports_Match.valueTags(failure, {
   NotSignedIn: ({ message }) => ({ message, remedy: "Run `ambral login`." }),
+  CliOutdated: ({ minimum: minimum2 }) => ({
+    message: `This ambral (v${package_default.version}) is older than the server serves: it needs v${minimum2} or later.`,
+    remedy: "Update it with `npm install --global ambral@latest`, or run it as `npx ambral@latest`."
+  }),
   CredentialsError: ({ message, reason }) => ({
     message,
     remedy: reason === "unreadable" ? "Delete it and run `ambral login`." : null
@@ -60680,7 +62479,7 @@ var one2 = {
     table2([
       ["BASE URL", connection.baseUrl],
       ["MODEL", connection.model],
-      ...connection.headers.map((header) => [header.name, header.value ?? header.description])
+      ...connection.headers.map((header2) => [header2.name, header2.value ?? header2.description])
     ]),
     "",
     `Check that its sessions are recorded with \`ambral traces list ${workload.name}\`.`
@@ -60733,7 +62532,7 @@ var get30 = exports_Command.make("get", { name: nameArgument }, ({ name }) => ex
   const { org } = yield* acting;
   yield* print(one2, yield* platform2.workloads.get({ params: { org, workload: name } }));
 })).pipe(exports_Command.provide(inProject), exports_Command.withDescription("Show a workload: its primary model, its pool, and how an agent connects to it through the Gateway"), exports_Command.withExamples([{ command: "ambral workloads get support-agent --json", description: "As JSON" }]));
-var add6 = exports_Command.make("add", { name: nameArgument, model: modelArgument }, ({ name, model }) => exports_Effect.gen(function* () {
+var add7 = exports_Command.make("add", { name: nameArgument, model: modelArgument }, ({ name, model }) => exports_Effect.gen(function* () {
   const { platform: platform2 } = yield* Ambral;
   const { org } = yield* acting;
   yield* print(changed(name), yield* platform2.workloads.addToPool({ params: { org, workload: name, model } }));
@@ -60760,7 +62559,7 @@ var setPrimary = exports_Command.make("set-primary", { name: nameArgument, model
     description: "Roll back to the model it served before"
   }
 ]));
-var pool = exports_Command.make("pool").pipe(exports_Command.withDescription("Add models to a workload's pool, or remove them"), exports_Command.withSubcommands([add6, remove11]));
+var pool = exports_Command.make("pool").pipe(exports_Command.withDescription("Add models to a workload's pool, or remove them"), exports_Command.withSubcommands([add7, remove11]));
 var workloads = exports_Command.make("workloads").pipe(exports_Command.withDescription("Create, list and show the org's workloads, change their model pools, and choose the model that serves each"), exports_Command.withSubcommands([create6, list17, get30, setPrimary, pool]));
 
 // src/Cli.ts
@@ -60776,7 +62575,7 @@ var ambral = exports_Command.make("ambral").pipe(exports_Command.withDescription
   runs,
   keys5,
   skill
-]), exports_Command.provide(reporting(Failures, advise).pipe(exports_Layer.provide(layer16), exports_Layer.provideMerge(hint))), exports_Command.withGlobalFlags([Json3, Org2]));
+]), exports_Command.provide(reporting(Failures, advise).pipe(exports_Layer.provide(layer18), exports_Layer.provideMerge(hint))), exports_Command.withGlobalFlags([Json3, Org2]));
 var main = exports_Command.run(ambral, { version: package_default.version }).pipe(exports_Effect.catchTag("ShowHelp", (help) => help.errors.length === 0 ? exports_Effect.void : exports_Effect.fail(help)));
 
 // src/bin.ts