apps 0.0.1-beta.37 → 0.0.1-beta.39

package/js/{chunk-PHO7HXTC.js → chunk-VIU2XXA7.js}

@@ -1,7 +1,3 @@
-import {
-  EventEncoded,
-  decodeSchema
-} from "./chunk-V5DWGYRK.js";
 import {
   DecodeError,
   HttpClient,
@@ -23,7 +19,7 @@ import {
   text,
   uint8Array,
   urlParams
-} from "./chunk-KOOJUMLR.js";
+} from "./chunk-3MMG2H6M.js";
 import {
   Cause,
   Defect,
@@ -35,8 +31,11 @@ import {
   Service,
   String as String2,
   Struct,
+  TaggedClass,
+  TaggedError,
   Uint8Array as Uint8Array2,
   Undefined,
+  UndefinedOr,
   Union,
   Unknown,
   UnknownFromJsonString,
@@ -51,6 +50,7 @@ import {
   constVoid,
   context,
   declare,
+  decode2 as decode,
   decodeText,
   decodeTo,
   decodeUnknownEffect2 as decodeUnknownEffect,
@@ -59,13 +59,15 @@ import {
   encodeSync,
   encodeUnknownEffect2 as encodeUnknownEffect,
   ensure,
-  fail2 as fail,
-  fail4 as fail2,
+  fail,
+  fail2,
+  fail4 as fail3,
   failCause2 as failCause,
   flatMap2 as flatMap,
   fnUntraced,
   fromInput3 as fromInput,
   fromJsonString,
+  fromTransform,
   gen,
   getLastEncoding,
   getOrUndefined2 as getOrUndefined,
@@ -83,7 +85,7 @@ import {
   isSuspend,
   isUnion,
   isVoid,
-  make4 as make,
+  make2 as make,
   map2 as map,
   map3 as map2,
   map4 as map3,
@@ -91,14 +93,18 @@ import {
   mapError,
   memoize,
   merge,
+  millis,
   optional,
   pipeArguments,
   pipeThroughChannel,
-  provideContext2 as provideContext,
+  pipeTo,
+  provideContext,
   resolveAt,
-  succeed4 as succeed,
+  succeed,
+  succeed4 as succeed2,
   suspend,
   sync2 as sync,
+  tag,
   toCodecJson,
   toCodecStringTree,
   toEncoded,
@@ -106,8 +112,9 @@ import {
   toType,
   transform,
   transformEffect,
-  transformPull
-} from "./chunk-IJQ5LE74.js";
+  transformPull,
+  void_2 as void_
+} from "./chunk-MXDKXAY4.js";
 import {
   __export
 } from "./chunk-CZ7CSFO4.js";
@@ -152,6 +159,246 @@ __export(HttpApiSchema_exports, {
   status: () => status,
   withHeaders: () => withHeaders
 });
+
+// ../../node_modules/.bun/effect@4.0.1/node_modules/effect/dist/encoding/Sse.js
+var SseErrorTypeId = "~effect/encoding/Sse/SseError";
+var EventTooLarge = class extends (/* @__PURE__ */ TaggedError("EventTooLarge")) {
+  get message() {
+    return `Pending SSE event exceeded the maximum size of ${this.maxEventSize}`;
+  }
+};
+var SseError = class extends (/* @__PURE__ */ TaggedError("SseError")) {
+  /**
+   * Marks this value as an SSE decoding error.
+   *
+   * @stability unstable
+   * @since 4.0.0
+   */
+  [SseErrorTypeId] = SseErrorTypeId;
+  /**
+   * Delegates the public message to the underlying SSE error reason.
+   *
+   * @stability unstable
+   * @since 4.0.0
+   */
+  get message() {
+    return this.reason.message;
+  }
+};
+var defaultMaxEventSize = 10 * 1024 * 1024;
+var decode2 = (options2) => fromTransform((upstream, _scope) => sync(() => {
+  let buffer = [];
+  let retry;
+  const parser = makeParser((event) => {
+    if (event._tag === "Retry") {
+      retry = event;
+    } else {
+      buffer.push(event);
+    }
+  }, options2);
+  const pump = flatMap(upstream, (arr) => {
+    for (let i = 0; i < arr.length; i++) {
+      const error = parser.feed(arr[i]);
+      if (error !== void 0) {
+        return fail3(error);
+      }
+    }
+    return void_;
+  });
+  return suspend(function loop() {
+    if (isArrayNonEmpty(buffer)) {
+      const out = buffer;
+      buffer = [];
+      return succeed2(out);
+    } else if (retry) {
+      return fail3(retry);
+    }
+    return flatMap(pump, loop);
+  });
+}));
+var decodeSchema = (schema, options2, parseOptions) => pipeTo(decode2(options2), decode(Event.pipe(decodeTo(schema, transformEvent)), parseOptions)());
+function makeParser(onParse, options2) {
+  const maxEventSize = options2?.maxEventSize ?? defaultMaxEventSize;
+  let isFirstChunk;
+  let buffer;
+  let startingPosition;
+  let startingFieldLength;
+  let discardTrailingNewline;
+  let lastEventId;
+  let eventName;
+  let data;
+  reset();
+  return {
+    feed,
+    reset
+  };
+  function reset() {
+    isFirstChunk = true;
+    buffer = "";
+    startingPosition = 0;
+    startingFieldLength = -1;
+    discardTrailingNewline = false;
+    lastEventId = void 0;
+    eventName = void 0;
+    data = "";
+  }
+  function feed(chunk) {
+    buffer = buffer ? buffer + chunk : chunk;
+    if (isFirstChunk && buffer.startsWith(BOM)) {
+      buffer = buffer.slice(BOM.length);
+    }
+    isFirstChunk = false;
+    const length = buffer.length;
+    let position = 0;
+    while (position < length) {
+      if (discardTrailingNewline) {
+        if (buffer[position] === "\n") {
+          ++position;
+        }
+        discardTrailingNewline = false;
+      }
+      let lineLength = -1;
+      let fieldLength = startingFieldLength;
+      let character;
+      for (let index = position + startingPosition; lineLength < 0 && index < length; ++index) {
+        character = buffer[index];
+        if (character === ":" && fieldLength < 0) {
+          fieldLength = index - position;
+        } else if (character === "\r") {
+          discardTrailingNewline = true;
+          lineLength = index - position;
+        } else if (character === "\n") {
+          lineLength = index - position;
+        }
+      }
+      if (lineLength < 0) {
+        startingPosition = length - position;
+        startingFieldLength = fieldLength;
+        break;
+      } else {
+        startingPosition = 0;
+        startingFieldLength = -1;
+      }
+      parseEventStreamLine(buffer, position, fieldLength, lineLength);
+      position += lineLength + 1;
+    }
+    if (position === length) {
+      buffer = "";
+    } else if (position > 0) {
+      buffer = buffer.slice(position);
+    }
+    if (buffer.length + data.length > maxEventSize) {
+      const error = new SseError({
+        reason: new EventTooLarge({
+          maxEventSize
+        })
+      });
+      reset();
+      return error;
+    }
+  }
+  function parseEventStreamLine(lineBuffer, index, fieldLength, lineLength) {
+    if (lineLength === 0) {
+      if (data.length > 0) {
+        onParse({
+          _tag: "Event",
+          id: lastEventId,
+          event: eventName || "message",
+          data: data.slice(0, -1)
+          // remove trailing newline
+        });
+        data = "";
+      }
+      eventName = void 0;
+      return;
+    }
+    const noValue = fieldLength < 0;
+    const field = lineBuffer.slice(index, index + (noValue ? lineLength : fieldLength));
+    let step = 0;
+    if (noValue) {
+      step = lineLength;
+    } else if (lineBuffer[index + fieldLength + 1] === " ") {
+      step = fieldLength + 2;
+    } else {
+      step = fieldLength + 1;
+    }
+    const position = index + step;
+    const valueLength = lineLength - step;
+    const value = lineBuffer.slice(position, position + valueLength).toString();
+    if (field === "data") {
+      data += value ? `${value}
+` : "\n";
+    } else if (field === "event") {
+      eventName = value;
+    } else if (field === "id" && !value.includes("\0")) {
+      lastEventId = value;
+    } else if (field === "retry" && /^\d+$/.test(value)) {
+      const retry = parseInt(value, 10);
+      onParse(new Retry({
+        duration: millis(retry),
+        lastEventId
+      }));
+    }
+  }
+}
+var BOM = "\uFEFF";
+var EventEncoded = /* @__PURE__ */ Struct({
+  id: /* @__PURE__ */ optional(String2),
+  event: String2,
+  data: String2
+});
+var Event = /* @__PURE__ */ Struct({
+  _tag: /* @__PURE__ */ tag("Event"),
+  id: /* @__PURE__ */ UndefinedOr(String2),
+  event: String2,
+  data: String2
+});
+var transformEvent = /* @__PURE__ */ transform({
+  decode: (event) => event.id === void 0 ? {
+    event: event.event,
+    data: event.data
+  } : {
+    id: event.id,
+    event: event.event,
+    data: event.data
+  },
+  encode: (event) => ({
+    _tag: "Event",
+    id: event.id,
+    event: event.event ?? "message",
+    data: event.data
+  })
+});
+var RetryTypeId = "~effect/encoding/Sse/Retry";
+var Retry = class _Retry extends (/* @__PURE__ */ TaggedClass("Retry")) {
+  /**
+   * Marks this value as an SSE retry directive for runtime guards.
+   *
+   * @stability unstable
+   * @since 4.0.0
+   */
+  [RetryTypeId] = RetryTypeId;
+  /**
+   * Returns `true` when the value is an SSE retry directive.
+   *
+   * @stability unstable
+   * @since 4.0.0
+   */
+  static is(u) {
+    return hasProperty(u, RetryTypeId);
+  }
+  /**
+   * Separates SSE retry directives from regular event values.
+   *
+   * @stability unstable
+   * @since 4.0.0
+   */
+  static filter(u) {
+    return _Retry.is(u) ? succeed(u) : fail(u);
+  }
+};
+
+// ../../node_modules/.bun/effect@4.0.1/node_modules/effect/dist/http-api/HttpApiSchema.js
 var StreamSchemaTypeId = "~effect/http-api/HttpApiSchema/Stream";
 function status(code) {
   const statusCode = typeof code === "string" ? fromLiteral(code) : code;
@@ -786,10 +1033,10 @@ var Proto2 = {
       groups: map(this.groups, (group2) => group2.prefix(prefix))
     });
   },
-  middleware(tag) {
+  middleware(tag2) {
     return makeProto2({
       ...optionsFromApi(this),
-      groups: map(this.groups, (group2) => group2.middleware(tag))
+      groups: map(this.groups, (group2) => group2.middleware(tag2))
     });
   },
   annotate(key, value) {
@@ -847,16 +1094,16 @@ var reflect = (self, options2) => {
   }
 };
 var extractResponseContent = (schemas, getStatus) => {
-  const map5 = /* @__PURE__ */ new Map();
+  const map7 = /* @__PURE__ */ new Map();
   schemas.forEach(add2);
-  return map5;
+  return map7;
   function add2(schema) {
     const body = isWithHeaders(schema) ? schema.schema : schema;
     if (isStreamSchema(body)) return;
     const status2 = getStatus(schema);
-    const schemas2 = map5.get(status2);
+    const schemas2 = map7.get(status2);
     if (schemas2 === void 0) {
-      map5.set(status2, [schema]);
+      map7.set(status2, [schema]);
     } else {
       schemas2.push(schema);
     }
@@ -1036,13 +1283,13 @@ var makeClient = (api, options2) => gen(function* () {
         }
       }
       for (const [status2, alternatives] of errorAlternatives.entries()) {
-        const decode = makeResponseDecoder(alternatives);
-        decodeMap[status2] = (response) => flatMap(catchCause(decode(response), (cause) => failCause(combine(fail(new HttpClientError({
+        const decode3 = makeResponseDecoder(alternatives);
+        decodeMap[status2] = (response) => flatMap(catchCause(decode3(response), (cause) => failCause(combine(fail2(new HttpClientError({
           reason: new StatusCodeError({
             request: response.request,
             response
           })
-        })), cause))), fail2);
+        })), cause))), fail3);
       }
       const successAlternatives = /* @__PURE__ */ new Map();
       for (const [status2, schemas] of successes.entries()) {
@@ -1063,7 +1310,7 @@ var makeClient = (api, options2) => gen(function* () {
       const encodePayload = isArrayNonEmpty(payloadSchemas) ? encodeUnknownEffect(hasBody(endpoint2.method) ? getEncodePayloadSchema(payloadSchemas, endpoint2.method) : Union(payloadSchemas), parseOptions.payload) : void 0;
       const encodeHeaders = map4(endpoint2.headers, (schema) => encodeUnknownEffect(schema, parseOptions.headers));
       const encodeQuery = map4(endpoint2.query, (schema) => encodeUnknownEffect(schema, parseOptions.query));
-      const middlewareKeys = Array.from(onEndpointOptions.middleware, (tag) => `${tag.key}/Client`);
+      const middlewareKeys = Array.from(onEndpointOptions.middleware, (tag2) => `${tag2.key}/Client`);
       const endpointFn = fnUntraced(function* (request) {
         let httpRequest = make2(endpoint2.method)(endpoint2.path);
         if (request !== void 0) {
@@ -1227,11 +1474,11 @@ var compilePath = (path, schema) => {
 function schemasToResponse(schemas, options2, headersOptions) {
   const hasWithHeaders = schemas.some((schema) => isWithHeaders(schema) || getWithHeadersAnnotation(schema.ast) !== void 0);
   const codec = hasWithHeaders ? Union(schemas.map((schema) => toCodecArrayBufferWithHeaders(schema, options2, headersOptions))) : toCodecArrayBuffer(schemas);
-  const decode = decodeUnknownEffect(codec, options2);
-  return (response) => flatMap(response.arrayBuffer, hasWithHeaders ? (body) => decode({
+  const decode3 = decodeUnknownEffect(codec, options2);
+  return (response) => flatMap(response.arrayBuffer, hasWithHeaders ? (body) => decode3({
     body,
     headers: response.headers
-  }) : decode);
+  }) : decode3);
 }
 var ResponsePair = /* @__PURE__ */ Struct({
   body: Unknown,
@@ -1259,23 +1506,23 @@ function toCodecArrayBufferWithHeaders(schema, options2, headersOptions) {
       body: decodeBody(pair.body),
       headers: decodeHeaders(pair.headers)
     }).pipe(map2(parts.toValue), mapError((error) => error.issue)),
-    encode: (input, options3) => fail2(new Forbidden({
+    encode: (input, options3) => fail3(new Forbidden({
       message: "Decode only schema"
     }, input, options3))
   })));
 }
-function addResponseAlternative(map5, status2, contentType, decode) {
+function addResponseAlternative(map7, status2, contentType, decode3) {
   const normalizedContentType = normalize(contentType);
-  const alternatives = map5.get(status2);
+  const alternatives = map7.get(status2);
   if (alternatives === void 0) {
-    map5.set(status2, [{
+    map7.set(status2, [{
       contentType: normalizedContentType,
-      decode
+      decode: decode3
     }]);
   } else {
     alternatives.push({
       contentType: normalizedContentType,
-      decode
+      decode: decode3
     });
   }
 }
@@ -1306,7 +1553,7 @@ function groupSchemasByContentType(schemas) {
 }
 function failUnsupportedContentType(response, contentType, alternatives) {
   const expected = Array.from(new Set(alternatives.map((alternative) => alternative.contentType))).join(", ");
-  return fail2(new HttpClientError({
+  return fail3(new HttpClientError({
     reason: new DecodeError({
       request: response.request,
       response,
@@ -1342,13 +1589,13 @@ function streamToResponse(successSchema, options2, headersOptions) {
   })));
 }
 function makeSseDecoder(declaration, parseOptions) {
-  const Event = Union([Struct({
+  const Event2 = Union([Struct({
     id: optional(String2),
     event: Literal(reservedStreamFailureEvent2),
     data: fromJsonString(toCodecJson(Cause(declaration.error, Defect())))
   }), declaration.events]);
-  const defaultDecoder = decodeSchema(Event, void 0, parseOptions);
-  return (options2) => options2 === void 0 ? defaultDecoder : decodeSchema(Event, options2, parseOptions);
+  const defaultDecoder = decodeSchema(Event2, void 0, parseOptions);
+  return (options2) => options2 === void 0 ? defaultDecoder : decodeSchema(Event2, options2, parseOptions);
 }
 function decodeSseStream(stream, declaration, decoder) {
   const events = transformPull(stream.pipe(decodeText, pipeThroughChannel(decoder)), (pull) => sync(() => {
@@ -1369,7 +1616,7 @@ function decodeSseStream(stream, declaration, decoder) {
             break;
           }
         }
-        return succeed(events2);
+        return succeed2(events2);
       });
     });
   }));
@@ -1433,7 +1680,7 @@ function fromArrayBuffer(schema) {
       return StringFromArrayBuffer;
   }
 }
-var statusOrElse = (response) => fail2(new HttpClientError({
+var statusOrElse = (response) => fail3(new HttpClientError({
   reason: new DecodeError({
     request: response.request,
     response
@@ -1453,49 +1700,49 @@ function getEncodePayloadSchemaFromBody(schema, method) {
   const encoding = getPayloadEncoding(ast, method);
   const out = $HttpBody.pipe(decodeTo(schema, transformEffect({
     decode(input, options2) {
-      return fail2(new Forbidden({
+      return fail3(new Forbidden({
         message: "Encode only schema"
       }, input, options2));
     },
     encode(t, options2) {
       switch (encoding._tag) {
         case "Multipart":
-          return fail2(new Forbidden({
+          return fail3(new Forbidden({
             message: "Payload must be a FormData"
           }, t, options2));
         case "Json": {
           try {
             const body = JSON.stringify(t);
-            return succeed(text(body, encoding.contentType));
+            return succeed2(text(body, encoding.contentType));
           } catch {
-            return fail2(new InvalidValue({
+            return fail3(new InvalidValue({
               expected: "a JSON-serializable request body"
             }, t, options2));
           }
         }
         case "Text": {
           if (typeof t !== "string") {
-            return fail2(new InvalidValue({
+            return fail3(new InvalidValue({
               message: "Expected a string"
             }, t, options2));
           }
-          return succeed(text(t, encoding.contentType));
+          return succeed2(text(t, encoding.contentType));
         }
         case "FormUrlEncoded": {
           if (!isObject(t)) {
-            return fail2(new InvalidValue({
+            return fail3(new InvalidValue({
               message: "Expected a record"
             }, t, options2));
           }
-          return succeed(urlParams(fromInput(t), encoding.contentType));
+          return succeed2(urlParams(fromInput(t), encoding.contentType));
         }
         case "Uint8Array": {
           if (!(t instanceof Uint8Array)) {
-            return fail2(new InvalidValue({
+            return fail3(new InvalidValue({
               message: "Expected a Uint8Array"
             }, t, options2));
           }
-          return succeed(uint8Array(t, encoding.contentType));
+          return succeed2(uint8Array(t, encoding.contentType));
         }
       }
     }

package/js/{chunk-TADLIUEU.js → chunk-VJQXXOQ3.js}

@@ -4,7 +4,7 @@ import {
   fromWeb,
   layerMergedContext,
   make2 as make
-} from "./chunk-KOOJUMLR.js";
+} from "./chunk-3MMG2H6M.js";
 import {
   Reference,
   Service,
@@ -17,7 +17,7 @@ import {
   succeed4 as succeed,
   toReadableStreamEffect,
   tryPromise
-} from "./chunk-IJQ5LE74.js";
+} from "./chunk-MXDKXAY4.js";
 import {
   __export
 } from "./chunk-CZ7CSFO4.js";

package/js/{chunk-NHCFIWN5.js → chunk-W2NV54JD.js}

@@ -1,6 +1,6 @@
 import {
   Schema_exports
-} from "./chunk-IJQ5LE74.js";
+} from "./chunk-MXDKXAY4.js";
 
 // src/contracts/ui-auth.ts
 var AppSignInId = Schema_exports.String.check(Schema_exports.isPattern(/^[a-f0-9]{64}$/)).pipe(

package/js/{chunk-BI45HZWM.js → chunk-YQ35E7KS.js}

@@ -1,6 +1,6 @@
 import {
   Schema_exports
-} from "./chunk-IJQ5LE74.js";
+} from "./chunk-MXDKXAY4.js";
 
 // src/contracts/schema.ts
 var JsonValue = Schema_exports.Json;

package/js/{chunk-WDBUOIWV.js → chunk-ZUKBIHMK.js}

@@ -1,15 +1,15 @@
 import {
   JsonValue
-} from "./chunk-BI45HZWM.js";
+} from "./chunk-YQ35E7KS.js";
 import {
   HttpApiEndpoint_exports,
   HttpApiGroup_exports,
   HttpApiSchema_exports,
   HttpApi_exports
-} from "./chunk-PHO7HXTC.js";
+} from "./chunk-VIU2XXA7.js";
 import {
   Schema_exports
-} from "./chunk-IJQ5LE74.js";
+} from "./chunk-MXDKXAY4.js";
 
 // src/contracts/ui.ts
 var UiContext = Schema_exports.Struct({

package/js/client.js

@@ -3,41 +3,36 @@ import {
   UiContext,
   UiDeploymentChanged,
   UiFailed
-} from "./chunk-WDBUOIWV.js";
+} from "./chunk-ZUKBIHMK.js";
 import {
   AsyncResult_exports,
   AtomRegistry_exports,
   Atom_exports,
   queryResult
-} from "./chunk-A4O72Z3A.js";
-import "./chunk-HDAQBRT5.js";
+} from "./chunk-DKUEYTYD.js";
 import {
   OtlpExporter_exports,
   externalTrace,
   pendingSpan,
   telemetryLayer,
   traceLinks
-} from "./chunk-24EIFQYZ.js";
+} from "./chunk-PCV73KVK.js";
 import {
   FetchHttpClient_exports
-} from "./chunk-TADLIUEU.js";
+} from "./chunk-VJQXXOQ3.js";
 import {
   decoderOf
-} from "./chunk-POOIHRPF.js";
-import {
-  StorageName
-} from "./chunk-Y3XN4X4Q.js";
-import "./chunk-2FWXCU5I.js";
+} from "./chunk-GHXRRFZA.js";
+import "./chunk-KAQD3DTI.js";
 import {
   JsonValue
-} from "./chunk-BI45HZWM.js";
+} from "./chunk-YQ35E7KS.js";
 import {
   HttpApiClient_exports
-} from "./chunk-PHO7HXTC.js";
-import "./chunk-V5DWGYRK.js";
+} from "./chunk-VIU2XXA7.js";
 import {
   HttpClientError_exports
-} from "./chunk-KOOJUMLR.js";
+} from "./chunk-3MMG2H6M.js";
 import {
   Cause_exports,
   Clock_exports,
@@ -56,20 +51,21 @@ import {
   Semaphore_exports,
   Stream_exports,
   Tracer_exports
-} from "./chunk-IJQ5LE74.js";
+} from "./chunk-MXDKXAY4.js";
 import "./chunk-CZ7CSFO4.js";
 
 // src/contracts/live.ts
+var OperationName = Schema_exports.NonEmptyString.check(Schema_exports.isMaxLength(200));
 var AppQueryFailed = class extends Schema_exports.TaggedError()("AppQueryFailed", {}) {
 };
 
 // src/implementation/live.ts
 var queryReference = (name) => ({
-  name: Schema_exports.decodeUnknownSync(StorageName)(name),
+  name: Schema_exports.decodeUnknownSync(OperationName)(name),
   kind: "query"
 });
 var mutationReference = (name) => ({
-  name: Schema_exports.decodeUnknownSync(StorageName)(name),
+  name: Schema_exports.decodeUnknownSync(OperationName)(name),
   kind: "mutation"
 });
 var liveQueryAtom = (reference, input, options) => Atom_exports.make(