apps 0.0.1-beta.8 → 0.0.1-beta.80

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

@@ -1,27 +1,56 @@
+import {
+  getWithReads
+} from "./chunk-OK4MIBPW.js";
+import {
+  fromPromise,
+  method,
+  toPromise
+} from "./chunk-ZYXY6JLH.js";
 import {
   CacheError
-} from "./chunk-R3EV5FTO.js";
+} from "./chunk-Q4IZAUIF.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,
+  Exit_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 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 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 +64,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 +119,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 +177,54 @@ 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 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* 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();
@@ -174,16 +246,23 @@ var catalogCache = (options) => Effect_exports.gen(function* () {
         options.summary.schema
       );
     }),
-    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))
-        )
-      )
+    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
 };

package/js/{chunk-27F7W2LG.js → chunk-H2CJWXA3.js}

@@ -1,12 +1,12 @@
 import {
   Schema_exports
-} from "./chunk-CDL5PM2Q.js";
+} from "./chunk-IFJU5SYQ.js";
 
 // src/contracts/schema.ts
 var JsonValue = Schema_exports.Json;
 var JsonObject = Schema_exports.Record(Schema_exports.String, JsonValue);
 var AccountId = Schema_exports.String.pipe(
-  Schema_exports.check(Schema_exports.isStartsWith("acc_"), Schema_exports.isMinLength(5)),
+  Schema_exports.check(Schema_exports.isStartingWith("acc_"), Schema_exports.isMinLength(5)),
   Schema_exports.brand("acc")
 );
 var HttpUrl = Schema_exports.String.check(

package/js/{chunk-JU7VHODU.js → chunk-H72MEDMN.js}

@@ -1,6 +1,49 @@
 import {
+  RecordedMessage
+} from "./chunk-5FHWNLCI.js";
+import {
+  SchemaGetter_exports,
   Schema_exports
-} from "./chunk-CDL5PM2Q.js";
+} from "./chunk-IFJU5SYQ.js";
+
+// ../utils/src/api-error.ts
+var MessageField = Schema_exports.String.pipe(
+  Schema_exports.decodeTo(Schema_exports.optionalKey(Schema_exports.String), {
+    decode: SchemaGetter_exports.omit(),
+    encode: SchemaGetter_exports.passthrough()
+  })
+);
+function withFields(definition) {
+  const fields = definition.fields;
+  const message = definition.message;
+  const documentation = typeof message === "string" ? { description: message } : {};
+  const DefinedError = Schema_exports.Error(definition.tag)(
+    Schema_exports.TaggedStruct(definition.tag, { ...fields, message: MessageField }).annotate(
+      documentation
+    ),
+    { httpApiStatus: definition.status, ...documentation }
+  );
+  const recorded = definition.recorded ?? (typeof message === "string" ? () => message : void 0);
+  Object.defineProperties(DefinedError.prototype, {
+    message: {
+      get() {
+        return typeof message === "string" ? message : message(this);
+      }
+    },
+    ...recorded === void 0 ? {} : {
+      [RecordedMessage]: {
+        get() {
+          return recorded(this);
+        }
+      }
+    }
+  });
+  return DefinedError;
+}
+function define(definition) {
+  return "fields" in definition ? withFields(definition) : withFields({ ...definition, fields: {} });
+}
+var ApiError = { define };
 
 // src/contracts/skills.ts
 var SkillFilePath = Schema_exports.NonEmptyString.check(
@@ -45,9 +88,18 @@ var AppSkillSource = Schema_exports.Struct({
     )
   )
 });
-var SkillDefinitionInvalid = class extends Schema_exports.TaggedError()(
-  "SkillDefinitionInvalid",
-  {
+var skillDefinitionFailures = {
+  files: (file) => `The skill files of \u201C${file}\u201D are invalid: each needs a unique relative path, text content and a SKILL.md document.`,
+  directory: (file) => `\u201C${file}\u201D is not a valid skill directory. Skill directory names use lowercase letters and digits separated by single hyphens.`,
+  "missing-document": (file) => `\u201C${file}\u201D is missing.`,
+  frontmatter: (file) => `\u201C${file}\u201D must start with valid YAML frontmatter between --- lines.`,
+  metadata: (file) => `The frontmatter of \u201C${file}\u201D needs a valid name and description within the Agent Skills limits.`,
+  "name-mismatch": (file) => `The name in \u201C${file}\u201D does not match its skill directory.`
+};
+var SkillDefinitionInvalid = ApiError.define({
+  tag: "SkillDefinitionInvalid",
+  status: 400,
+  fields: {
     file: SkillFilePath,
     reason: Schema_exports.Literals([
       "files",
@@ -58,14 +110,14 @@ var SkillDefinitionInvalid = class extends Schema_exports.TaggedError()(
       "name-mismatch"
     ])
   },
-  { httpApiStatus: 400 }
-) {
-};
+  message: ({ file, reason }) => skillDefinitionFailures[reason](file),
+  recorded: ({ reason }) => `The app's skill definition is invalid (${reason})`
+});
 var AppSkills = Schema_exports.Array(AppSkillSource).check(
   Schema_exports.makeFilter((skills) => new Set(skills.map((skill) => skill.name)).size === skills.length)
 );
 var SkillServiceName = Schema_exports.String.check(
-  Schema_exports.isPattern(/^[A-Za-z0-9](?:[A-Za-z0-9 .-]{0,98}[A-Za-z0-9])?$/)
+  Schema_exports.isPattern(/^[A-Za-z0-9](?:[A-Za-z0-9 .-]{0,98}[A-Za-z0-9])?$/u)
 );
 var SkillLoadFailed = class extends Schema_exports.TaggedError()("SkillLoadFailed", {
   reason: Schema_exports.Literals([
@@ -79,14 +131,17 @@ var SkillLoadFailed = class extends Schema_exports.TaggedError()("SkillLoadFaile
   ]),
   // Error instances read an omitted message as "", so an empty message means none was given.
   message: Schema_exports.optional(Schema_exports.String.check(Schema_exports.isMaxLength(500))),
-  status: Schema_exports.optional(Schema_exports.Int.check(Schema_exports.isBetween({ minimum: 100, maximum: 599 })))
+  status: Schema_exports.optional(Schema_exports.Int.check(Schema_exports.isBetween({ minimum: 100, maximum: 599 }))),
+  missing: Schema_exports.optional(Schema_exports.Literals(["repository", "ref"]))
 }) {
 };
 var skillLoadLimits = {
   files: 1e3,
   fileBytes: 2e6,
   totalBytes: 2e7,
-  concurrency: 8
+  concurrency: 8,
+  /** The request that checks whether a kept catalog's publication changed. */
+  checkMillis: 5e3
 };
 
 export {