apps 0.0.1-beta.7 → 0.0.1-beta.73

package/js/chunk-7LMU3ER3.js

@@ -0,0 +1,274 @@
+import {
+  AccountId
+} from "./chunk-H2CJWXA3.js";
+import {
+  Schema_exports
+} from "./chunk-IFJU5SYQ.js";
+
+// src/contracts/failure.ts
+var maxFailureMessageLength = 2048;
+var FailureSource = Schema_exports.Literals(["app", "storage", "service"]);
+var FailureName = Schema_exports.String.check(Schema_exports.isMaxLength(128));
+var FailureCode = Schema_exports.String.check(Schema_exports.isMaxLength(128));
+var FailureMessage = Schema_exports.String.check(Schema_exports.isMaxLength(maxFailureMessageLength));
+var maxFailureFields = 8;
+var maxFailureFieldLength = 256;
+var FailureFieldName = Schema_exports.String.check(
+  Schema_exports.isPattern(/^[A-Za-z_$][A-Za-z0-9_$]{0,63}$/)
+);
+var FailureFieldValue = Schema_exports.Union([
+  Schema_exports.String.check(Schema_exports.isMaxLength(maxFailureFieldLength)),
+  Schema_exports.Finite,
+  Schema_exports.Boolean
+]);
+var FailureFields = Schema_exports.Record(FailureFieldName, FailureFieldValue).check(
+  Schema_exports.isMaxProperties(maxFailureFields)
+);
+var FailureDetail = {
+  source: Schema_exports.optionalKey(FailureSource),
+  errorName: Schema_exports.optionalKey(FailureName),
+  code: Schema_exports.optionalKey(FailureCode),
+  message: Schema_exports.optionalKey(FailureMessage),
+  fields: Schema_exports.optionalKey(FailureFields)
+};
+var maxUpstreamMessageLength = 1024;
+var UpstreamError = Schema_exports.Struct({
+  code: Schema_exports.Union([
+    Schema_exports.Int,
+    Schema_exports.String.check(Schema_exports.isMinLength(1), Schema_exports.isMaxLength(128))
+  ]),
+  message: Schema_exports.optionalKey(Schema_exports.String.check(Schema_exports.isMaxLength(maxUpstreamMessageLength)))
+});
+var FailurePhase = Schema_exports.Literals(["connect", "discover", "call"]);
+
+// src/contracts/provider-error.ts
+var ProviderError = class extends Schema_exports.TaggedError()("ProviderError", {
+  reason: Schema_exports.Literals(["unauthorized", "forbidden", "rate_limited", "unavailable", "rejected"]),
+  status: Schema_exports.optional(Schema_exports.Int.check(Schema_exports.isBetween({ minimum: 100, maximum: 599 }))),
+  accountId: Schema_exports.optional(AccountId),
+  phase: Schema_exports.optional(FailurePhase),
+  upstream: Schema_exports.optional(UpstreamError)
+}) {
+};
+
+// src/contracts/network.ts
+var NetworkRefusal = Schema_exports.Union([
+  Schema_exports.Struct({ reason: Schema_exports.Literal("private_address") }),
+  Schema_exports.Struct({
+    reason: Schema_exports.Literal("credential_host"),
+    /** The provider of the credential handle the request carried. */
+    provider: Schema_exports.String,
+    /** The hosts that provider's credentials may reach; empty when it declares none. */
+    allowedHosts: Schema_exports.Array(Schema_exports.String)
+  }),
+  Schema_exports.Struct({ reason: Schema_exports.Literal("credential_app") }),
+  Schema_exports.Struct({
+    reason: Schema_exports.Literal("credential_expired"),
+    /** The provider of the expired credential handle. */
+    provider: Schema_exports.String
+  }),
+  Schema_exports.Struct({
+    reason: Schema_exports.Literal("credential_placement"),
+    /** The provider of the misplaced credential handle. */
+    provider: Schema_exports.String,
+    /** Where the handle was found, such as `body` or `header x-note`. */
+    location: Schema_exports.String
+  }),
+  Schema_exports.Struct({
+    reason: Schema_exports.Literal("credential_transport"),
+    /** The provider of the credential handle the request carried. */
+    provider: Schema_exports.String
+  }),
+  Schema_exports.Struct({
+    reason: Schema_exports.Literal("credential_method"),
+    /** The refused HTTP method. */
+    method: Schema_exports.String
+  })
+]);
+var NetworkRefused = class extends Schema_exports.TaggedError()("NetworkRefused", {
+  /** The refused destination, with its port when the URL names one. */
+  host: Schema_exports.String,
+  refusal: NetworkRefusal
+}) {
+  get message() {
+    const refusal = this.refusal;
+    switch (refusal.reason) {
+      case "private_address":
+        return `Executor refused a request to ${this.host}: apps on this instance can reach only public addresses, and ${this.host} is a private, loopback or internal address. The request was not sent.`;
+      case "credential_host":
+        return refusal.allowedHosts.length === 0 ? `Executor refused this request: ${refusal.provider} credentials cannot be sent to ${this.host}: the provider declares no hosts.` : `Executor refused this request: ${refusal.provider} credentials cannot be sent to ${this.host}. The provider allows: ${refusal.allowedHosts.join(", ")}.`;
+      case "credential_app":
+        return "Executor refused this request: it carries a credential handle that is not valid for this app. Use the account fields this invocation received.";
+      case "credential_expired":
+        return `Executor refused this request: it carries an expired ${refusal.provider} credential handle. Use the account fields this invocation received.`;
+      case "credential_placement":
+        return `Executor refused this request: it carries a ${refusal.provider} credential handle in the ${refusal.location}, where the provider does not place it. Send credentials only as the provider's request declares, for example with the account's headers() and url().`;
+      case "credential_transport":
+        return `Executor refused this request: ${refusal.provider} credentials are sent only over HTTPS, and ${this.host} was requested over plain HTTP.`;
+      case "credential_method":
+        return `Executor refused this request: credential handles are never sent with ${refusal.method}, which asks the service to echo the request back.`;
+    }
+  }
+};
+var networkRefusalStatus = 421;
+var networkRefusalHeader = "x-executor-refused";
+var NetworkRefusedHeader = Schema_exports.StringFromUriComponent.pipe(
+  Schema_exports.decodeTo(Schema_exports.fromJsonString(NetworkRefused))
+);
+var encodeRefusal = Schema_exports.encodeSync(NetworkRefused);
+var encodeRefusalHeader = Schema_exports.encodeSync(NetworkRefusedHeader);
+var networkRefusalResponse = (refused) => new Response(JSON.stringify({ ...encodeRefusal(refused), message: refused.message }), {
+  status: networkRefusalStatus,
+  statusText: "Refused by Executor",
+  headers: {
+    "content-type": "application/json; charset=utf-8",
+    [networkRefusalHeader]: encodeRefusalHeader(refused)
+  }
+});
+var RestrictedFetchOption = Schema_exports.Literals(["redirect", "cache", "integrity"]);
+var supportedFetchOptions = {
+  redirect: ["follow", "manual"],
+  cache: ["no-store", "no-cache"],
+  integrity: [""]
+};
+var FetchOptionUnsupported = class extends Schema_exports.TaggedError()(
+  "FetchOptionUnsupported",
+  {
+    option: RestrictedFetchOption,
+    value: Schema_exports.String,
+    supported: Schema_exports.Array(Schema_exports.String)
+  }
+) {
+  get message() {
+    const supported = this.supported.map((value) => JSON.stringify(value)).join(" or ");
+    return `fetch option ${this.option}: ${JSON.stringify(this.value)} is not supported by Executor's app runtime. Use ${supported}, or omit ${this.option}.${this.advice}`;
+  }
+  /** What to do instead, when the standard value has an equivalent the runtime supports. */
+  get advice() {
+    switch (this.option) {
+      case "redirect":
+        return this.value === "error" ? ` To reject redirects, send redirect: "manual" and treat a 3xx response as the error.` : "";
+      case "cache":
+        return "";
+      case "integrity":
+        return " To check a digest, read the body and hash it with crypto.subtle.digest.";
+    }
+  }
+};
+
+// ../app-cache/src/contracts/cache.ts
+var CacheError = class extends Schema_exports.TaggedError()("CacheError", {
+  reason: Schema_exports.Literals(["unavailable", "storage", "invalid", "capacity", "timeout"]),
+  /** Which of `cacheLimits` the request exceeded, when one did. */
+  limit: Schema_exports.optionalKey(
+    Schema_exports.Literals([
+      "keyBytes",
+      "entryBytes",
+      "batchBytes",
+      "batchEntries",
+      "totalBytes",
+      "totalEntries"
+    ])
+  )
+}) {
+};
+var cacheLimits = {
+  keyBytes: 8192,
+  entryBytes: 2e6,
+  batchBytes: 8e6,
+  batchEntries: 128,
+  totalBytes: 128e6,
+  totalEntries: 1e5,
+  retentionMs: 7 * 24 * 60 * 60 * 1e3,
+  loadTimeoutMs: 9e4,
+  /**
+   * A loader's lease lapses this long after its host last renewed it. Hosts renew every
+   * `renewMs` while the invocation that claimed it runs, so a stalled or lost holder frees the
+   * key well inside an MCP execute budget.
+   */
+  leaseMs: 15e3,
+  renewMs: 5e3,
+  /** The longest a caller waits on another loader before loading for itself without publishing. */
+  waitMs: 1e4,
+  /** Bound for one command to a host store; a lost reply fails instead of holding its caller. */
+  commandTimeoutMs: 1e4
+};
+var Key = Schema_exports.String.check(Schema_exports.isPattern(/^[a-f0-9]{64}$/));
+var Time = Schema_exports.Finite.check(Schema_exports.isGreaterThanOrEqualTo(0));
+var CacheEntry = Schema_exports.Struct({
+  value: Schema_exports.Json,
+  version: Schema_exports.String,
+  freshUntil: Time,
+  staleUntil: Time
+});
+var CacheAcquired = Schema_exports.Struct({
+  entry: Schema_exports.NullOr(CacheEntry),
+  lease: Schema_exports.NullOr(Schema_exports.String)
+});
+var CacheCommand = Schema_exports.Union([
+  Schema_exports.Struct({ operation: Schema_exports.Literal("read"), keys: Schema_exports.Array(Key) }),
+  Schema_exports.Struct({
+    operation: Schema_exports.Literal("acquire"),
+    key: Key,
+    /** Claim even a fresh entry, as an explicit refresh does. */
+    refresh: Schema_exports.Boolean,
+    /** Claim only while the entry still has this version. Absent accepts the current one. */
+    version: Schema_exports.optionalKey(Schema_exports.NullOr(Schema_exports.String))
+  }),
+  Schema_exports.Struct({
+    operation: Schema_exports.Literal("claim"),
+    key: Key,
+    version: Schema_exports.NullOr(Schema_exports.String)
+  }),
+  Schema_exports.Struct({
+    operation: Schema_exports.Literal("publish"),
+    key: Key,
+    lease: Schema_exports.String,
+    entry: CacheEntry
+  }),
+  Schema_exports.Struct({ operation: Schema_exports.Literal("release"), key: Key, lease: Schema_exports.String }),
+  /** Extend a lease its holder still owns. Replies false once the lease lapsed or was replaced. */
+  Schema_exports.Struct({ operation: Schema_exports.Literal("renew"), key: Key, lease: Schema_exports.String }),
+  Schema_exports.Struct({
+    operation: Schema_exports.Literal("write"),
+    entries: Schema_exports.Array(Schema_exports.Struct({ key: Key, entry: CacheEntry }))
+  }),
+  Schema_exports.Struct({ operation: Schema_exports.Literal("invalidate"), key: Key })
+]);
+var CacheReply = Schema_exports.Union([
+  Schema_exports.Struct({ ok: Schema_exports.Literal(true), value: Schema_exports.Json }),
+  Schema_exports.Struct({ ok: Schema_exports.Literal(false), error: CacheError })
+]);
+
+export {
+  maxFailureMessageLength,
+  FailureSource,
+  FailureName,
+  FailureCode,
+  FailureMessage,
+  maxFailureFields,
+  maxFailureFieldLength,
+  FailureFieldName,
+  FailureFieldValue,
+  FailureFields,
+  FailureDetail,
+  maxUpstreamMessageLength,
+  UpstreamError,
+  FailurePhase,
+  ProviderError,
+  NetworkRefusal,
+  NetworkRefused,
+  networkRefusalStatus,
+  networkRefusalHeader,
+  NetworkRefusedHeader,
+  networkRefusalResponse,
+  RestrictedFetchOption,
+  supportedFetchOptions,
+  FetchOptionUnsupported,
+  CacheError,
+  cacheLimits,
+  CacheEntry,
+  CacheAcquired,
+  CacheCommand,
+  CacheReply
+};

package/js/chunk-CDXQDN7W.js

@@ -0,0 +1,92 @@
+import {
+  JsonValue
+} from "./chunk-H2CJWXA3.js";
+import {
+  HttpApiEndpoint_exports,
+  HttpApiGroup_exports,
+  HttpApiSchema_exports,
+  HttpApi_exports
+} from "./chunk-TUMGL2OC.js";
+import {
+  Schema_exports
+} from "./chunk-IFJU5SYQ.js";
+
+// src/contracts/ui.ts
+var UiContext = Schema_exports.Struct({
+  deployment: Schema_exports.NonEmptyString,
+  profile: Schema_exports.optional(Schema_exports.NonEmptyString),
+  expectedProfileRevision: Schema_exports.optional(Schema_exports.Int)
+});
+var UiOperation = Schema_exports.Struct({
+  ...UiContext.fields,
+  name: Schema_exports.NonEmptyString,
+  input: JsonValue
+});
+var UiUnauthorized = class extends Schema_exports.TaggedError()(
+  "UiUnauthorized",
+  {},
+  { httpApiStatus: 401 }
+) {
+};
+var UiForbidden = class extends Schema_exports.TaggedError()(
+  "UiForbidden",
+  {},
+  { httpApiStatus: 403 }
+) {
+};
+var UiDeploymentChanged = class extends Schema_exports.TaggedError()(
+  "UiDeploymentChanged",
+  {},
+  { httpApiStatus: 409 }
+) {
+};
+var UiFailed = class extends Schema_exports.TaggedError()(
+  "UiFailed",
+  {
+    reason: Schema_exports.Literals(["unavailable", "operation_failed", "account_required"])
+  },
+  { httpApiStatus: 422 }
+) {
+};
+var UiSnapshot = Schema_exports.Union([
+  Schema_exports.Struct({
+    type: Schema_exports.Literal("snapshot"),
+    value: JsonValue,
+    trace: Schema_exports.optional(Schema_exports.Unknown)
+  }),
+  Schema_exports.Struct({ type: Schema_exports.Literal("failure"), error: UiFailed }),
+  Schema_exports.Struct({ type: Schema_exports.Literal("heartbeat") })
+]);
+var errors = [UiUnauthorized, UiForbidden, UiDeploymentChanged, UiFailed];
+var AppUiApi = HttpApi_exports.make("app-ui").add(
+  HttpApiGroup_exports.make("ui").add(
+    HttpApiEndpoint_exports.post("query", "/_executor/api/query", {
+      payload: UiOperation,
+      success: JsonValue,
+      error: errors
+    })
+  ).add(
+    HttpApiEndpoint_exports.post("mutate", "/_executor/api/mutate", {
+      payload: UiOperation,
+      success: JsonValue,
+      error: errors
+    })
+  ).add(
+    HttpApiEndpoint_exports.post("subscribe", "/_executor/api/subscribe", {
+      payload: UiOperation,
+      success: HttpApiSchema_exports.StreamSse({ data: UiSnapshot, error: Schema_exports.Union(errors) }),
+      error: errors
+    })
+  )
+);
+
+export {
+  UiContext,
+  UiOperation,
+  UiUnauthorized,
+  UiForbidden,
+  UiDeploymentChanged,
+  UiFailed,
+  UiSnapshot,
+  AppUiApi
+};

package/js/{chunk-RFVIONFX.js → chunk-ECCWT5GJ.js}

@@ -1,19 +1,35 @@
+import {
+  fromPromise,
+  method,
+  toPromise
+} from "./chunk-ZR7QAG67.js";
 import {
   CacheError
-} from "./chunk-R3EV5FTO.js";
+} from "./chunk-7LMU3ER3.js";
 import {
   wrap
-} from "./chunk-5T57N25Q.js";
+} from "./chunk-KGCTYL2S.js";
 import {
   JsonObject
-} from "./chunk-27F7W2LG.js";
+} from "./chunk-H2CJWXA3.js";
 import {
+  Deferred_exports,
   Duration_exports,
   Effect_exports,
   Schema_exports
-} from "./chunk-CDL5PM2Q.js";
+} from "./chunk-IFJU5SYQ.js";
 
 // src/implementation/catalog-cache.ts
+var catalogScope = (options, credential, invalid) => {
+  const { account, cache } = options;
+  if (account === void 0)
+    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("unselected-account")
+  });
+};
 var schema = (decoder) => wrap(decoder, false);
 var Manifest = Schema_exports.Struct({
   revision: Schema_exports.String,
@@ -21,7 +37,6 @@ var Manifest = Schema_exports.Struct({
   summaries: Schema_exports.Int,
   header: Schema_exports.optionalKey(JsonObject)
 });
-var invoke = (work) => Effect_exports.tryPromise({ try: work, catch: (error) => error });
 var catalogCache = (options) => Effect_exports.gen(function* () {
   const cache = options.cache;
   const key = [...options.prefix, "current"];
@@ -35,14 +50,42 @@ var catalogCache = (options) => Effect_exports.gen(function* () {
   const staleFor = options.staleFor ?? "1 day";
   const retention = Duration_exports.toMillis(Duration_exports.fromInputUnsafe(freshFor)) + Duration_exports.toMillis(Duration_exports.fromInputUnsafe(staleFor)) + 3e5;
   const local = yield* Effect_exports.cached(options.load());
+  const pages = (cache2, revision, kind, count, decoder) => Effect_exports.gen(function* () {
+    const batches = yield* Effect_exports.forEach(
+      Array.from({ length: Math.ceil(count / 4) }, (_, batch) => batch * 4),
+      (offset) => fromPromise(method(cache2, "readMany"), "cache")(
+        Array.from(
+          { length: Math.min(4, count - offset) },
+          (_, index) => part(revision, kind, offset + index)
+        ),
+        schema(Schema_exports.Array(decoder))
+      ),
+      { concurrency: "unbounded" }
+    );
+    const values = [];
+    for (const page of batches.flat()) {
+      if (page === void 0) return yield* new CacheError({ reason: "unavailable" });
+      values.push(...page);
+    }
+    return values;
+  });
+  const kept = (cache2) => fromPromise(method(cache2, "read"), "cache")(key, schema(Manifest)).pipe(
+    Effect_exports.map(
+      (manifest) => manifest === void 0 ? void 0 : {
+        header: manifest.header,
+        tools: pages(cache2, manifest.revision, "page", manifest.pages, options.schema)
+      }
+    )
+  );
   const refresh = (context) => Effect_exports.gen(function* () {
-    const { tools, header } = yield* options.load(context);
-    const digest = yield* invoke(
-      () => crypto.subtle.digest(
+    const { tools, header } = yield* options.load(context, kept(context.cache));
+    const digest = yield* Effect_exports.tryPromise({
+      try: () => crypto.subtle.digest(
         "SHA-256",
         new TextEncoder().encode(JSON.stringify({ tools, header: header ?? null }))
-      )
-    );
+      ),
+      catch: (error) => error
+    });
     const revision = Array.from(
       new Uint8Array(digest),
       (byte) => byte.toString(16).padStart(2, "0")
@@ -62,7 +105,7 @@ var catalogCache = (options) => Effect_exports.gen(function* () {
       batch = [];
       batchBytes = 0;
       if (!entries.length) return Effect_exports.void;
-      return invoke(() => context.cache.write(entries, retention)).pipe(
+      return fromPromise(method(context.cache, "write"), "cache")(entries, retention).pipe(
         Effect_exports.withSpan("app.cache.flush", {
           attributes: {
             "cache.flush.index": flushes++,
@@ -120,39 +163,32 @@ var catalogCache = (options) => Effect_exports.gen(function* () {
     schema: schema(Manifest),
     freshFor,
     staleFor,
-    load: (context) => Effect_exports.runPromise(refresh(context), { signal: context.signal })
+    ...options.stale === void 0 ? {} : { stale: options.stale },
+    // A cache may call the loader as a Promise; its own signal cancels that load.
+    load: toPromise(refresh, (context) => context.signal)
   };
   let reading;
-  const current = () => cache === void 0 ? Effect_exports.fail(new CacheError({ reason: "unavailable" })) : invoke(
-    () => reading ??= cache.get(getOptions).finally(() => {
-      reading = void 0;
-    })
-  );
+  const current = () => Effect_exports.suspend(() => {
+    if (cache === void 0) return Effect_exports.fail(new CacheError({ reason: "unavailable" }));
+    const shared = reading;
+    if (shared !== void 0) return Deferred_exports.await(shared);
+    const deferred = Deferred_exports.makeUnsafe();
+    reading = deferred;
+    return fromPromise(
+      method(cache, "get"),
+      "cache"
+    )(getOptions).pipe(
+      Effect_exports.onExit(
+        (exit) => Effect_exports.sync(() => {
+          if (reading === deferred) reading = void 0;
+        }).pipe(Effect_exports.andThen(Deferred_exports.done(deferred, exit)))
+      )
+    );
+  });
   if (options.revalidate) {
     if (cache === void 0) yield* local;
-    else yield* invoke(() => cache.revalidate(getOptions));
+    else yield* fromPromise(method(cache, "revalidate"), "cache")(getOptions);
   }
-  const pages = (cache2, revision, kind, count, decoder) => Effect_exports.gen(function* () {
-    const batches = yield* Effect_exports.forEach(
-      Array.from({ length: Math.ceil(count / 4) }, (_, batch) => batch * 4),
-      (offset) => invoke(
-        () => cache2.readMany(
-          Array.from(
-            { length: Math.min(4, count - offset) },
-            (_, index) => part(revision, kind, offset + index)
-          ),
-          schema(Schema_exports.Array(decoder))
-        )
-      ),
-      { concurrency: "unbounded" }
-    );
-    const values = [];
-    for (const page of batches.flat()) {
-      if (page === void 0) return yield* new CacheError({ reason: "unavailable" });
-      values.push(...page);
-    }
-    return values;
-  });
   const metadata = () => Effect_exports.gen(function* () {
     if (cache === void 0) return (yield* local).tools;
     const manifest = yield* current();
@@ -176,8 +212,9 @@ var catalogCache = (options) => Effect_exports.gen(function* () {
     }),
     resolve: (name) => cache === void 0 ? local.pipe(Effect_exports.map(({ tools }) => tools.find((tool) => tool.name === name))) : current().pipe(
       Effect_exports.flatMap(
-        (manifest) => invoke(
-          () => cache.read(part(manifest.revision, "tool", name), schema(options.schema))
+        (manifest) => fromPromise(method(cache, "read"), "cache")(
+          part(manifest.revision, "tool", name),
+          schema(options.schema)
         )
       )
     )
@@ -185,5 +222,6 @@ var catalogCache = (options) => Effect_exports.gen(function* () {
 });
 
 export {
+  catalogScope,
   catalogCache
 };