apps 0.0.1-beta.33 → 0.0.1-beta.35

package/js/{chunk-O3OAFU7Q.js → chunk-POOIHRPF.js}

@@ -1,7 +1,7 @@
 import {
   JsonObject,
   ValidationError
-} from "./chunk-FBBXFFFJ.js";
+} from "./chunk-BI45HZWM.js";
 import {
   Cause_exports,
   Effect_exports,
@@ -10,7 +10,7 @@ import {
   SchemaIssue_exports,
   SchemaParser_exports,
   Schema_exports
-} from "./chunk-EXGKN554.js";
+} from "./chunk-IJQ5LE74.js";
 
 // ../../node_modules/.bun/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/deep-compare-strict.js
 function deepCompareStrict(a, b) {

package/js/{chunk-AUFVX4KM.js → chunk-RSNZDT4L.js}

@@ -1,9 +1,9 @@
 import {
   appSignInCallbackPath
-} from "./chunk-ZOY7PDMI.js";
+} from "./chunk-NHCFIWN5.js";
 import {
   HttpServerResponse_exports
-} from "./chunk-CJY5X26R.js";
+} from "./chunk-KOOJUMLR.js";
 
 // src/implementation/ui-auth.ts
 var appPrivateHeaders = {

package/js/chunk-SRB2WDU7.js

@@ -0,0 +1,49 @@
+import {
+  FetchOptionUnsupported,
+  NetworkRefusedHeader,
+  RestrictedFetchOption,
+  networkRefusalHeader,
+  networkRefusalStatus,
+  supportedFetchOptions
+} from "./chunk-BI6R577B.js";
+import {
+  invocationFetch
+} from "./chunk-KZFV3WCJ.js";
+import {
+  Effect_exports,
+  Schema_exports
+} from "./chunk-IJQ5LE74.js";
+
+// src/implementation/network.ts
+var refusalHeader = (status, header) => status === networkRefusalStatus && header !== null && header !== void 0 ? header : void 0;
+var failOnNetworkRefusal = (response) => {
+  const header = refusalHeader(response.status, response.headers[networkRefusalHeader]);
+  return header === void 0 ? Effect_exports.void : Schema_exports.decodeUnknownEffect(NetworkRefusedHeader)(header).pipe(
+    Effect_exports.orDie,
+    Effect_exports.flatMap(Effect_exports.fail)
+  );
+};
+var unsupportedOption = (init) => {
+  for (const option of RestrictedFetchOption.literals) {
+    const value = init?.[option];
+    const supported = supportedFetchOptions[option];
+    if (value !== void 0 && !supported.includes(value))
+      return new FetchOptionUnsupported({ option, value: String(value), supported });
+  }
+  return void 0;
+};
+var appFetch = (fetch) => async (input, init) => {
+  const unsupported = unsupportedOption(init);
+  if (unsupported !== void 0) throw unsupported;
+  const response = await fetch(input, init);
+  const header = refusalHeader(response.status, response.headers.get(networkRefusalHeader));
+  if (header === void 0) return response;
+  await response.body?.cancel();
+  throw Schema_exports.decodeUnknownSync(NetworkRefusedHeader)(header);
+};
+var appInvocationFetch = (signal) => invocationFetch(signal).pipe(Effect_exports.map(appFetch));
+
+export {
+  failOnNetworkRefusal,
+  appInvocationFetch
+};

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

@@ -4,7 +4,7 @@ import {
   fromWeb,
   layerMergedContext,
   make2 as make
-} from "./chunk-CJY5X26R.js";
+} from "./chunk-KOOJUMLR.js";
 import {
   Reference,
   Service,
@@ -13,16 +13,16 @@ import {
   getOrUndefined2 as getOrUndefined,
   map3 as map,
   merge3 as merge,
-  remove3 as remove,
+  remove2 as remove,
   succeed4 as succeed,
   toReadableStreamEffect,
   tryPromise
-} from "./chunk-EXGKN554.js";
+} from "./chunk-IJQ5LE74.js";
 import {
   __export
 } from "./chunk-CZ7CSFO4.js";
 
-// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/node_modules/effect/dist/unstable/http/FetchHttpClient.js
+// ../../node_modules/.bun/effect@4.0.1/node_modules/effect/dist/http/FetchHttpClient.js
 var FetchHttpClient_exports = {};
 __export(FetchHttpClient_exports, {
   Fetch: () => Fetch,

package/js/{chunk-3BHBWZLD.js → chunk-UWOIEJ56.js}

@@ -1,9 +1,8 @@
 import {
   makeCache
-} from "./chunk-AYM2FUI5.js";
+} from "./chunk-JU7F4PRK.js";
 import {
   accountSecrets,
-  appInvocationFetch,
   boundFailureMessage,
   describeFailure,
   failureDetail,
@@ -11,32 +10,35 @@ import {
   parseMcpError,
   readCatalog,
   routerSkills
-} from "./chunk-2SRLJHPM.js";
+} from "./chunk-YYK6GEMC.js";
+import {
+  appInvocationFetch
+} from "./chunk-SRB2WDU7.js";
 import {
   folderSkillsEffect
-} from "./chunk-OX233L7N.js";
+} from "./chunk-FFTALB6S.js";
 import {
   ResponseStatusError,
   authorDatabase,
   isApp,
   toEffectApp,
   unavailableStorage
-} from "./chunk-E6C2DUIA.js";
+} from "./chunk-KBXQOJYW.js";
 import {
   parseDatabaseSchema
-} from "./chunk-5JVNM3CQ.js";
+} from "./chunk-IU7CCCUC.js";
 import {
   declaredOperations,
   fromPromise,
   locate,
   nativeOperation,
   toPromise
-} from "./chunk-75JKK3ZE.js";
+} from "./chunk-VBVOPW4U.js";
 import {
   accountProviderError,
   httpProviderError,
   parseProviderError
-} from "./chunk-4OKYLVU4.js";
+} from "./chunk-ENJCQWVF.js";
 import {
   AccountCheckResult,
   DeclaredProvider,
@@ -83,18 +85,18 @@ import {
   defaultWebhookTransportLimits,
   maxInputProblems,
   workflowDurationMillis
-} from "./chunk-N72RKJ5E.js";
+} from "./chunk-5KNA2Z5I.js";
 import {
   CacheError
-} from "./chunk-5DLG2FVN.js";
+} from "./chunk-BI6R577B.js";
 import {
   AppSkills,
   SkillFile,
   SkillLoadFailed
-} from "./chunk-HW3DPBZR.js";
+} from "./chunk-I7CNZ4CM.js";
 import {
   captureTelemetry
-} from "./chunk-ETLILMHY.js";
+} from "./chunk-KZFV3WCJ.js";
 import {
   allowedValues,
   decoderOf,
@@ -105,16 +107,16 @@ import {
   maxAlternativeKeys,
   objectShape,
   unionShape
-} from "./chunk-O3OAFU7Q.js";
+} from "./chunk-POOIHRPF.js";
 import {
   JsonObject,
   JsonValue
-} from "./chunk-FBBXFFFJ.js";
+} from "./chunk-BI45HZWM.js";
 import {
+  Base64_exports,
   Cause_exports,
   Clock_exports,
   Effect_exports,
-  Encoding_exports,
   Match_exports,
   Option_exports,
   Redacted_exports,
@@ -122,7 +124,7 @@ import {
   SchemaIssue_exports,
   Schema_exports,
   Stream_exports
-} from "./chunk-EXGKN554.js";
+} from "./chunk-IJQ5LE74.js";
 
 // src/implementation/elicitation.ts
 var prepareElicitation = (input) => Effect_exports.gen(function* () {
@@ -518,7 +520,7 @@ var dispatchWebhook = (definition, command, context, accounts) => Effect_exports
     yield* invoke(hook.unregister, { ...input, state });
     return null;
   }
-  const body = yield* Effect_exports.fromResult(Encoding_exports.decodeBase64(command.request.body)).pipe(
+  const body = yield* Effect_exports.fromResult(Base64_exports.decode(command.request.body)).pipe(
     Effect_exports.mapError(() => new HostInputInvalid())
   );
   if (body.byteLength > defaultWebhookTransportLimits.maxBodyBytes)
@@ -567,7 +569,7 @@ var dispatchWebhook = (definition, command, context, accounts) => Effect_exports
     () => Schema_exports.decodeUnknownEffect(WebhookResponseData)({
       status: response.status,
       headers,
-      body: Encoding_exports.encodeBase64(new Uint8Array(bytes))
+      body: Base64_exports.encode(new Uint8Array(bytes))
     }),
     new HostOutputInvalid()
   );

package/js/chunk-V5DWGYRK.js

@@ -0,0 +1,268 @@
+import {
+  String,
+  Struct,
+  TaggedClass,
+  TaggedError,
+  UndefinedOr,
+  decode2 as decode,
+  decodeTo,
+  fail,
+  fail4 as fail2,
+  flatMap2 as flatMap,
+  fromTransform,
+  hasProperty,
+  isArrayNonEmpty,
+  millis,
+  optional,
+  pipeTo,
+  succeed,
+  succeed4 as succeed2,
+  suspend,
+  sync2 as sync,
+  tag,
+  transform,
+  void_2 as void_
+} from "./chunk-IJQ5LE74.js";
+
+// ../../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 = (options) => fromTransform((upstream, _scope) => sync(() => {
+  let buffer = [];
+  let retry;
+  const parser = makeParser((event) => {
+    if (event._tag === "Retry") {
+      retry = event;
+    } else {
+      buffer.push(event);
+    }
+  }, options);
+  const pump = flatMap(upstream, (arr) => {
+    for (let i = 0; i < arr.length; i++) {
+      const error = parser.feed(arr[i]);
+      if (error !== void 0) {
+        return fail2(error);
+      }
+    }
+    return void_;
+  });
+  return suspend(function loop() {
+    if (isArrayNonEmpty(buffer)) {
+      const out = buffer;
+      buffer = [];
+      return succeed2(out);
+    } else if (retry) {
+      return fail2(retry);
+    }
+    return flatMap(pump, loop);
+  });
+}));
+var decodeSchema = (schema, options, parseOptions) => pipeTo(decode2(options), decode(Event.pipe(decodeTo(schema, transformEvent)), parseOptions)());
+function makeParser(onParse, options) {
+  const maxEventSize = options?.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(String),
+  event: String,
+  data: String
+});
+var Event = /* @__PURE__ */ Struct({
+  _tag: /* @__PURE__ */ tag("Event"),
+  id: /* @__PURE__ */ UndefinedOr(String),
+  event: String,
+  data: String
+});
+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);
+  }
+};
+
+export {
+  decodeSchema,
+  EventEncoded
+};

package/js/{chunk-75JKK3ZE.js → chunk-VBVOPW4U.js}

@@ -3,15 +3,15 @@ import {
   RouterKey,
   RouterMeta,
   reservedRouterKeys
-} from "./chunk-N72RKJ5E.js";
+} from "./chunk-5KNA2Z5I.js";
 import {
   decoderOf,
   schemaArgument
-} from "./chunk-O3OAFU7Q.js";
+} from "./chunk-POOIHRPF.js";
 import {
   Effect_exports,
   Schema_exports
-} from "./chunk-EXGKN554.js";
+} from "./chunk-IJQ5LE74.js";
 
 // src/implementation/authoring.ts
 var NativeCallback = /* @__PURE__ */ Symbol("apps.NativeCallback");

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

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

package/js/{chunk-6KG4DZD7.js → chunk-Y3XN4X4Q.js}

@@ -1,6 +1,6 @@
 import {
   Schema_exports
-} from "./chunk-EXGKN554.js";
+} from "./chunk-IJQ5LE74.js";
 
 // src/contracts/storage.ts
 var StorageName = Schema_exports.NonEmptyString.check(Schema_exports.isMaxLength(200));

package/js/{chunk-WWSRAE5Y.js → chunk-YW333DH3.js}

@@ -1,25 +1,28 @@
 import {
   CacheError
-} from "./chunk-5DLG2FVN.js";
+} from "./chunk-BI6R577B.js";
 import {
   wrap
-} from "./chunk-O3OAFU7Q.js";
+} from "./chunk-POOIHRPF.js";
 import {
   JsonObject
-} from "./chunk-FBBXFFFJ.js";
+} from "./chunk-BI45HZWM.js";
 import {
   Duration_exports,
   Effect_exports,
   Schema_exports
-} from "./chunk-EXGKN554.js";
+} from "./chunk-IJQ5LE74.js";
 
 // src/implementation/catalog-cache.ts
-var catalogScope = (options, invalid) => {
-  const { account, cache, headers } = options;
+var catalogScope = (options, credential, invalid) => {
+  const { account, cache } = options;
   if (account === void 0)
-    return headers === void 0 ? Effect_exports.succeed(cache) : Effect_exports.fail(invalid());
+    return credential === void 0 ? Effect_exports.succeed(cache) : Effect_exports.fail(invalid("missing-account"));
   if (cache === void 0) return Effect_exports.succeed(void 0);
-  return Effect_exports.try({ try: () => cache.forAccount(account), catch: invalid });
+  return Effect_exports.try({
+    try: () => cache.forAccount(account),
+    catch: () => invalid("unselected-account")
+  });
 };
 var schema = (decoder) => wrap(decoder, false);
 var Manifest = Schema_exports.Struct({