apps 0.0.1-beta.1 → 0.0.1-beta.100

package/js/chunk-VCYWAA4N.js

@@ -0,0 +1,49 @@
+import {
+  FetchOptionUnsupported,
+  NetworkRefusedHeader,
+  RestrictedFetchOption,
+  networkRefusalHeader,
+  networkRefusalStatus,
+  supportedFetchOptions
+} from "./chunk-4UPC36ZL.js";
+import {
+  invocationFetch
+} from "./chunk-URKOTNDA.js";
+import {
+  Effect_exports,
+  Schema_exports
+} from "./chunk-ZKDXML77.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-HDJH3RPR.js → chunk-YDW7DX3A.js}

@@ -4,7 +4,7 @@ import {
   fromWeb,
   layerMergedContext,
   make2 as make
-} from "./chunk-QKHR7BMF.js";
+} from "./chunk-ACQXVKVQ.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-FW5HBOIK.js";
+} from "./chunk-ZKDXML77.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-YWVISRZD.js

@@ -0,0 +1,268 @@
+import {
+  getWithReads
+} from "./chunk-5C6RAGAS.js";
+import {
+  fromPromise,
+  method,
+  toPromise
+} from "./chunk-7STIP5CS.js";
+import {
+  CacheError
+} from "./chunk-4UPC36ZL.js";
+import {
+  wrap
+} from "./chunk-VAI3EVCS.js";
+import {
+  JsonObject
+} from "./chunk-7HG422GB.js";
+import {
+  Deferred_exports,
+  Duration_exports,
+  Effect_exports,
+  Exit_exports,
+  Schema_exports
+} from "./chunk-ZKDXML77.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 seenRevisions = /* @__PURE__ */ new Map();
+var seenLimit = 256;
+var seen = (key, revision) => {
+  seenRevisions.delete(key);
+  seenRevisions.set(key, revision);
+  if (seenRevisions.size > seenLimit) {
+    const oldest = seenRevisions.keys().next();
+    if (oldest.done !== true) seenRevisions.delete(oldest.value);
+  }
+};
+var Manifest = Schema_exports.Struct({
+  revision: Schema_exports.String,
+  pages: Schema_exports.Int,
+  summaries: Schema_exports.Int,
+  header: Schema_exports.optionalKey(JsonObject)
+});
+var catalogCache = (options) => Effect_exports.gen(function* () {
+  const cache = options.cache;
+  const key = [...options.prefix, "current"];
+  const part = (revision, kind, name) => [
+    ...options.prefix,
+    revision,
+    kind,
+    name
+  ];
+  const freshFor = options.freshFor ?? "5 minutes";
+  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, 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")
+    ).join("");
+    let pages2 = 0;
+    let page = [];
+    let pageBytes = 0;
+    let summaries = 0;
+    let summary = [];
+    let summaryBytes = 0;
+    let batch = [];
+    let batchBytes = 0;
+    let flushes = 0;
+    const flush = () => Effect_exports.suspend(() => {
+      const entries = batch;
+      const bytes = batchBytes;
+      batch = [];
+      batchBytes = 0;
+      if (!entries.length) return Effect_exports.void;
+      return fromPromise(method(context.cache, "write"), "cache")(entries, retention).pipe(
+        Effect_exports.withSpan("app.cache.flush", {
+          attributes: {
+            "cache.flush.index": flushes++,
+            "cache.flush.entries": entries.length,
+            "cache.flush.bytes": bytes
+          }
+        })
+      );
+    });
+    const append = (entry) => Effect_exports.gen(function* () {
+      const bytes = new TextEncoder().encode(JSON.stringify(entry)).byteLength;
+      if (batch.length && (batch.length >= 64 || batchBytes + bytes > 4e6))
+        yield* flush();
+      batch.push(entry);
+      batchBytes += bytes;
+    });
+    const pageOut = () => Effect_exports.gen(function* () {
+      if (!page.length) return;
+      yield* append({ key: part(revision, "page", pages2++), value: page });
+      page = [];
+      pageBytes = 0;
+    });
+    const summaryOut = () => Effect_exports.gen(function* () {
+      if (!summary.length) return;
+      yield* append({ key: part(revision, "summary", summaries++), value: summary });
+      summary = [];
+      summaryBytes = 0;
+    });
+    const json = (value) => Schema_exports.decodeUnknownEffect(Schema_exports.fromJsonString(JsonObject))(JSON.stringify(value));
+    for (const tool of tools) {
+      const value = yield* json(tool);
+      const bytes = new TextEncoder().encode(JSON.stringify(value)).byteLength;
+      if (page.length && (page.length >= 64 || pageBytes + bytes > 5e5)) yield* pageOut();
+      yield* append({ key: part(revision, "tool", tool.name), value });
+      page.push(value);
+      pageBytes += bytes;
+      const brief = yield* json(options.summary.of(tool));
+      const briefBytes = new TextEncoder().encode(JSON.stringify(brief)).byteLength;
+      if (summary.length && summaryBytes + briefBytes > 5e5) yield* summaryOut();
+      summary.push(brief);
+      summaryBytes += briefBytes;
+    }
+    yield* pageOut();
+    yield* summaryOut();
+    yield* flush();
+    return {
+      revision,
+      pages: pages2,
+      summaries,
+      ...header === void 0 ? {} : { header: yield* json(header) }
+    };
+  });
+  const getOptions = {
+    key,
+    schema: schema(Manifest),
+    freshFor,
+    staleFor,
+    ...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 read = (tool) => 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).pipe(Effect_exports.map((manifest) => ({ manifest })));
+      const deferred = Deferred_exports.makeUnsafe();
+      reading = deferred;
+      const together = Object.hasOwn(cache, getWithReads) ? cache[getWithReads] : void 0;
+      let hinted;
+      const fetched = together === void 0 ? fromPromise(
+        method(cache, "get"),
+        "cache"
+      )(getOptions).pipe(Effect_exports.map((manifest) => ({ manifest }))) : fromPromise(method({ together }, "together"), "cache")(getOptions, (stored) => {
+        hinted = tool === void 0 ? void 0 : seenRevisions.get(stored);
+        return hinted === void 0 || tool === void 0 ? [] : [part(hinted, "tool", tool)];
+      }).pipe(
+        Effect_exports.map(({ value: manifest, key: stored, reads }) => {
+          seen(stored, manifest.revision);
+          return manifest.revision === hinted && reads !== void 0 ? { manifest, part: { value: reads[0] } } : { manifest };
+        })
+      );
+      return fetched.pipe(
+        Effect_exports.onExit(
+          (exit) => Effect_exports.sync(() => {
+            if (reading === deferred) reading = void 0;
+          }).pipe(
+            Effect_exports.andThen(
+              Deferred_exports.done(
+                deferred,
+                Exit_exports.map(exit, ({ manifest }) => manifest)
+              )
+            )
+          )
+        )
+      );
+    }
+  );
+  const current = () => read().pipe(Effect_exports.map(({ manifest }) => manifest));
+  if (options.revalidate) {
+    if (cache === void 0) yield* local;
+    else yield* fromPromise(method(cache, "revalidate"), "cache")(getOptions);
+  }
+  const metadata = () => Effect_exports.gen(function* () {
+    if (cache === void 0) return (yield* local).tools;
+    const manifest = yield* current();
+    return yield* pages(cache, manifest.revision, "page", manifest.pages, options.schema);
+  });
+  return {
+    list: metadata,
+    /** The record stored with the current revision, if the source supplied one. */
+    header: () => cache === void 0 ? local.pipe(Effect_exports.map(({ header }) => header)) : current().pipe(Effect_exports.map((manifest) => manifest.header)),
+    summaries: () => Effect_exports.gen(function* () {
+      if (cache === void 0)
+        return (yield* local).tools.map((tool) => options.summary.of(tool));
+      const manifest = yield* current();
+      return yield* pages(
+        cache,
+        manifest.revision,
+        "summary",
+        manifest.summaries,
+        options.summary.schema
+      );
+    }),
+    resolve: (name) => cache === void 0 ? local.pipe(Effect_exports.map(({ tools }) => tools.find((tool) => tool.name === name))) : read(name).pipe(
+      Effect_exports.flatMap(({ manifest, part: found }) => {
+        const separately = fromPromise(method(cache, "read"), "cache")(
+          part(manifest.revision, "tool", name),
+          schema(options.schema)
+        );
+        if (found === void 0) return separately;
+        if (found.value === void 0) return Effect_exports.succeed(void 0);
+        return Schema_exports.decodeUnknownEffect(options.schema)(found.value).pipe(
+          Effect_exports.catch(() => separately)
+        );
+      })
+    )
+  };
+});
+
+export {
+  catalogScope,
+  catalogCache
+};