apps 0.0.1-beta.0 → 0.0.1-beta.2

package/js/browser-XIPJGLH2.js

@@ -0,0 +1,65 @@
+import {
+  Alias,
+  Composer,
+  Document,
+  Lexer,
+  LineCounter,
+  Pair,
+  Parser,
+  Scalar,
+  Schema,
+  YAMLError,
+  YAMLMap,
+  YAMLParseError,
+  YAMLSeq,
+  YAMLWarning,
+  browser_default,
+  cst_exports,
+  isAlias,
+  isCollection,
+  isDocument,
+  isMap,
+  isNode,
+  isPair,
+  isScalar,
+  isSeq,
+  parse,
+  parseAllDocuments,
+  parseDocument,
+  stringify,
+  visit,
+  visitAsync
+} from "./chunk-UVL56Z6E.js";
+import "./chunk-CZ7CSFO4.js";
+export {
+  Alias,
+  cst_exports as CST,
+  Composer,
+  Document,
+  Lexer,
+  LineCounter,
+  Pair,
+  Parser,
+  Scalar,
+  Schema,
+  YAMLError,
+  YAMLMap,
+  YAMLParseError,
+  YAMLSeq,
+  YAMLWarning,
+  browser_default as default,
+  isAlias,
+  isCollection,
+  isDocument,
+  isMap,
+  isNode,
+  isPair,
+  isScalar,
+  isSeq,
+  parse,
+  parseAllDocuments,
+  parseDocument,
+  stringify,
+  visit,
+  visitAsync
+};

package/js/{chunk-SBKHUC5L.js → chunk-4LPG6RCH.js}

@@ -5,10 +5,10 @@ import {
   UiFailed,
   UiForbidden,
   UiUnauthorized
-} from "./chunk-3ANFZFCV.js";
+} from "./chunk-OHRT55C4.js";
 import {
   Schema_exports
-} from "./chunk-2OTCEKL2.js";
+} from "./chunk-FW5HBOIK.js";
 
 // src/contracts/ui-auth.ts
 var AppSignInId = Schema_exports.String.check(Schema_exports.isPattern(/^[a-f0-9]{64}$/)).pipe(

package/js/chunk-5MQZEB6Y.js

@@ -0,0 +1,172 @@
+import {
+  CacheError
+} from "./chunk-LGIYBDWA.js";
+import {
+  wrap
+} from "./chunk-WFSQXYUT.js";
+import {
+  JsonObject
+} from "./chunk-SATWJKN6.js";
+import {
+  Duration_exports,
+  Effect_exports,
+  Schema_exports
+} from "./chunk-FW5HBOIK.js";
+
+// src/implementation/catalog-cache.ts
+var schema = (decoder) => wrap(decoder, false);
+var Manifest = Schema_exports.Struct({
+  revision: Schema_exports.String,
+  pages: Schema_exports.Int,
+  summaries: Schema_exports.Int
+});
+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"];
+  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 refresh = (context) => Effect_exports.gen(function* () {
+    const tools = yield* options.load(context);
+    const digest = yield* invoke(
+      () => crypto.subtle.digest("SHA-256", new TextEncoder().encode(JSON.stringify(tools)))
+    );
+    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 invoke(() => context.cache.write(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 };
+  });
+  const getOptions = {
+    key,
+    schema: schema(Manifest),
+    freshFor,
+    staleFor,
+    load: (context) => Effect_exports.runPromise(refresh(context), { signal: context.signal })
+  };
+  const current = () => cache === void 0 ? Effect_exports.fail(new CacheError({ reason: "unavailable" })) : invoke(() => cache.get(getOptions));
+  if (options.revalidate) {
+    if (cache === void 0) yield* local;
+    else yield* invoke(() => cache.revalidate(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;
+    const manifest = yield* current();
+    return yield* pages(cache, manifest.revision, "page", manifest.pages, options.schema);
+  });
+  return {
+    list: metadata,
+    summaries: () => Effect_exports.gen(function* () {
+      if (cache === void 0) return (yield* local).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))) : current().pipe(
+      Effect_exports.flatMap(
+        (manifest) => invoke(
+          () => cache.read(part(manifest.revision, "tool", name), schema(options.schema))
+        )
+      )
+    )
+  };
+});
+
+export {
+  catalogCache
+};

package/js/{chunk-7JXHF5IF.js → chunk-BMOIAIVR.js}

@@ -1,6 +1,6 @@
 import {
   Schema_exports
-} from "./chunk-2OTCEKL2.js";
+} from "./chunk-FW5HBOIK.js";
 
 // ../app-data/src/contracts/database.ts
 var DataName = Schema_exports.String.check(

package/js/chunk-CZ7CSFO4.js

@@ -0,0 +1,39 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __commonJS,
+  __export,
+  __toESM
+};

package/js/chunk-D47C7KG5.js

@@ -0,0 +1,172 @@
+import {
+  CacheAcquired,
+  CacheEntry,
+  CacheError,
+  cacheLimits
+} from "./chunk-LGIYBDWA.js";
+import {
+  Clock_exports,
+  Duration_exports,
+  Effect_exports,
+  Exit_exports,
+  Schema_exports
+} from "./chunk-FW5HBOIK.js";
+
+// ../app-cache/src/index.ts
+var canonical = (value) => {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  if (value !== null && typeof value === "object")
+    return `{${Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`).join(",")}}`;
+  return JSON.stringify(value);
+};
+var cacheKey = (key) => Effect_exports.gen(function* () {
+  const parsed = yield* Schema_exports.decodeUnknownEffect(Schema_exports.Json)(key).pipe(
+    Effect_exports.mapError(() => new CacheError({ reason: "invalid" }))
+  );
+  const bytes = new TextEncoder().encode(canonical(parsed));
+  if (bytes.byteLength > cacheLimits.keyBytes)
+    return yield* new CacheError({ reason: "capacity" });
+  const hash = yield* Effect_exports.tryPromise({
+    try: () => crypto.subtle.digest("SHA-256", bytes),
+    catch: () => new CacheError({ reason: "invalid" })
+  });
+  return [...new Uint8Array(hash)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+});
+var makeCache = (host, background, scope = "shared", deadline) => {
+  const transport = (command) => host(command).pipe(
+    Effect_exports.withSpan("app.cache.command", {
+      attributes: { "cache.operation": command.operation }
+    })
+  );
+  const keyOf = (key) => cacheKey([scope, key]);
+  const readKeys = (keys) => transport({ operation: "read", keys }).pipe(
+    Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(Schema_exports.Array(Schema_exports.NullOr(CacheEntry)))),
+    Effect_exports.mapError(() => new CacheError({ reason: "storage" }))
+  );
+  const durations = (freshFor, staleFor = 0) => Effect_exports.try({
+    try: () => {
+      const fresh = Duration_exports.toMillis(Duration_exports.fromInputUnsafe(freshFor));
+      const stale = Duration_exports.toMillis(Duration_exports.fromInputUnsafe(staleFor));
+      if (![fresh, stale].every((value) => Number.isFinite(value) && value >= 0) || fresh + stale > cacheLimits.retentionMs)
+        throw new CacheError({ reason: "invalid" });
+      return { fresh, stale };
+    },
+    catch: () => new CacheError({ reason: "invalid" })
+  });
+  const get = (options, refresh) => Effect_exports.gen(function* () {
+    const key = yield* keyOf(options.key);
+    const { fresh, stale } = yield* durations(options.freshFor, options.staleFor);
+    const decode = (value) => Schema_exports.decodeUnknownEffect(options.schema)(value);
+    const load = (lease) => Effect_exports.gen(function* () {
+      const value = yield* options.load.pipe(Effect_exports.flatMap(decode));
+      const json = yield* Schema_exports.decodeUnknownEffect(Schema_exports.Json)(value).pipe(
+        Effect_exports.mapError(() => new CacheError({ reason: "invalid" }))
+      );
+      const now = yield* Clock_exports.currentTimeMillis;
+      const published = yield* transport({
+        operation: "publish",
+        key,
+        lease,
+        entry: {
+          value: json,
+          version: crypto.randomUUID(),
+          freshUntil: now + fresh,
+          staleUntil: now + fresh + stale
+        }
+      }).pipe(Effect_exports.withSpan("app.cache.publish"));
+      if (published !== true) return yield* new CacheError({ reason: "unavailable" });
+      return value;
+    }).pipe(
+      Effect_exports.withSpan("app.cache.load"),
+      Effect_exports.timeout(cacheLimits.loadTimeoutMs),
+      // Publishing clears the lease in the same transaction. Only an unpublished load releases it.
+      Effect_exports.onExit(
+        (exit) => Exit_exports.isSuccess(exit) ? Effect_exports.void : transport({ operation: "release", key, lease }).pipe(
+          Effect_exports.catch(() => Effect_exports.void)
+        )
+      )
+    );
+    const waitUntil = Math.min(
+      (yield* Clock_exports.currentTimeMillis) + cacheLimits.waitMs,
+      deadline ?? Number.POSITIVE_INFINITY
+    );
+    let initialVersion;
+    while (true) {
+      const { entry, lease } = yield* transport({
+        operation: "acquire",
+        key,
+        refresh,
+        ...initialVersion === void 0 ? {} : { version: initialVersion }
+      }).pipe(
+        Effect_exports.flatMap(
+          (reply) => Schema_exports.decodeUnknownEffect(CacheAcquired)(reply).pipe(
+            Effect_exports.mapError(() => new CacheError({ reason: "storage" }))
+          )
+        )
+      );
+      const now = yield* Clock_exports.currentTimeMillis;
+      if (initialVersion === void 0) initialVersion = entry?.version ?? null;
+      const refreshed = refresh && entry !== null && entry.version !== initialVersion;
+      if (entry !== null && (refreshed || !refresh && lease === null && now < entry.freshUntil)) {
+        yield* Effect_exports.annotateCurrentSpan("cache.result", "fresh");
+        return yield* decode(entry.value);
+      }
+      if (!refresh && entry !== null && now < entry.staleUntil) {
+        yield* Effect_exports.annotateCurrentSpan("cache.result", "stale");
+        if (lease !== null) yield* background(load(lease).pipe(Effect_exports.asVoid));
+        return yield* decode(entry.value);
+      }
+      if (lease !== null) {
+        yield* Effect_exports.annotateCurrentSpan("cache.result", "miss");
+        return yield* load(lease);
+      }
+      if (now >= waitUntil) {
+        yield* Effect_exports.annotateCurrentSpan("cache.result", "local");
+        return yield* options.load.pipe(
+          Effect_exports.flatMap(decode),
+          Effect_exports.timeout(cacheLimits.loadTimeoutMs),
+          Effect_exports.withSpan("app.cache.load", { attributes: { "cache.load.leased": false } })
+        );
+      }
+      yield* Effect_exports.sleep("100 millis");
+    }
+  }).pipe(Effect_exports.withSpan("app.cache.get"));
+  return {
+    /** Read arbitrary retained JSON entries without initiating a refresh. Missing and null are distinct. */
+    read: (keys) => Effect_exports.forEach(keys, keyOf).pipe(Effect_exports.flatMap(readKeys)),
+    /** Publish bounded immutable parts before publishing the manifest that references them. */
+    write: (entries, retention) => Effect_exports.gen(function* () {
+      const { fresh } = yield* durations(retention);
+      const now = yield* Clock_exports.currentTimeMillis;
+      const values = yield* Effect_exports.forEach(
+        entries,
+        ({ key, value }) => Effect_exports.gen(function* () {
+          return {
+            key: yield* keyOf(key),
+            entry: {
+              value,
+              version: crypto.randomUUID(),
+              freshUntil: now + fresh,
+              staleUntil: now + fresh
+            }
+          };
+        })
+      );
+      yield* transport({ operation: "write", entries: values });
+    }),
+    /** Revoke retained data and any loader's right to publish its in-flight result. */
+    invalidate: (key) => keyOf(key).pipe(
+      Effect_exports.flatMap((key2) => transport({ operation: "invalidate", key: key2 })),
+      Effect_exports.asVoid
+    ),
+    /** Read fresh data, refresh stale data in the background, or wait for the lease owner. */
+    get: (options) => get(options, false),
+    /** Force one awaited refresh without removing the retained value. Concurrent refreshes share a load. */
+    revalidate: (options) => get(options, true)
+  };
+};
+
+export {
+  cacheKey,
+  makeCache
+};

package/js/{chunk-YDR4CPJA.js → chunk-EVJUVWN2.js}

@@ -3,7 +3,7 @@ import {
   invalidate,
   layer,
   mutation
-} from "./chunk-D6BKYP2L.js";
+} from "./chunk-M6ZRRIBI.js";
 import {
   Boolean,
   Cause,
@@ -158,12 +158,12 @@ import {
   void_2,
   whileLoop,
   zipRight
-} from "./chunk-2OTCEKL2.js";
+} from "./chunk-FW5HBOIK.js";
 import {
   __export
-} from "./chunk-MLKGABMK.js";
+} from "./chunk-CZ7CSFO4.js";
 
-// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/reactivity/AsyncResult.js
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/node_modules/effect/dist/unstable/reactivity/AsyncResult.js
 var AsyncResult_exports = {};
 __export(AsyncResult_exports, {
   Schema: () => Schema,
@@ -600,7 +600,7 @@ var Schema = (options) => {
   });
 };
 
-// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/reactivity/AtomRegistry.js
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/node_modules/effect/dist/unstable/reactivity/AtomRegistry.js
 var AtomRegistry_exports = {};
 __export(AtomRegistry_exports, {
   AtomRegistry: () => AtomRegistry,
@@ -1340,7 +1340,7 @@ function batchRebuildNode(node) {
   }
 }
 
-// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/reactivity/Atom.js
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/node_modules/effect/dist/unstable/reactivity/Atom.js
 var Atom_exports = {};
 __export(Atom_exports, {
   Interrupt: () => Interrupt,
@@ -1400,7 +1400,7 @@ __export(Atom_exports, {
   writable: () => writable
 });
 
-// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/persistence/KeyValueStore.js
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/node_modules/effect/dist/unstable/persistence/KeyValueStore.js
 var ErrorTypeId = "~effect/persistence/KeyValueStore/KeyValueStoreError";
 var KeyValueStoreError = class extends (/* @__PURE__ */ TaggedError("KeyValueStoreError")) {
   /**
@@ -1442,7 +1442,7 @@ var toSchemaStore = (self, schema) => {
   };
 };
 
-// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/reactivity/Atom.js
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/node_modules/effect/dist/unstable/reactivity/Atom.js
 var TypeId3 = "~effect/reactivity/Atom";
 var isAtom = (u) => hasProperty(u, TypeId3);
 var WritableTypeId = "~effect/reactivity/Atom/Writable";

package/js/chunk-FDNTX5QJ.js

@@ -0,0 +1,78 @@
+import {
+  AppSkillMetadata,
+  AppSkillName,
+  AppSkillSource,
+  SkillDefinitionInvalid,
+  SkillFile,
+  SkillFilePath
+} from "./chunk-YEJOQEII.js";
+import {
+  Effect_exports,
+  Schema_exports
+} from "./chunk-FW5HBOIK.js";
+
+// src/implementation/skill-files.ts
+var skillFromFiles = (input, source = {}) => Effect_exports.gen(function* () {
+  const file = `${source.directory === void 0 ? "" : `${source.directory}/`}SKILL.md`;
+  const invalid = (reason) => new SkillDefinitionInvalid({ file, reason });
+  const files = yield* Schema_exports.decodeUnknownEffect(Schema_exports.Array(SkillFile))(input).pipe(
+    Effect_exports.mapError(() => invalid("files"))
+  );
+  const document = files.find((file2) => file2.path === "SKILL.md");
+  if (document === void 0) return yield* invalid("missing-document");
+  const match = /^\uFEFF?---[ \t]*\r?\n([\s\S]*?)\r?\n---(?:[ \t]*\r?\n|[ \t]*$)/.exec(
+    document.content
+  );
+  if (match?.[1] === void 0) return yield* invalid("frontmatter");
+  const frontmatter = match[1];
+  const { parseDocument } = (yield* Effect_exports.promise(() => import("./browser-XIPJGLH2.js"))).default;
+  const value = yield* Effect_exports.try({
+    try: () => {
+      const yaml = parseDocument(frontmatter);
+      if (yaml.errors.length) throw yaml.errors[0];
+      return yaml.toJS();
+    },
+    catch: () => invalid("frontmatter")
+  });
+  const metadata = yield* Schema_exports.decodeUnknownEffect(AppSkillMetadata)(value).pipe(
+    Effect_exports.mapError(() => invalid("metadata"))
+  );
+  if (source.name !== void 0 && metadata.name !== source.name)
+    return yield* invalid("name-mismatch");
+  return yield* Schema_exports.decodeUnknownEffect(AppSkillSource)({ ...metadata, files }).pipe(
+    Effect_exports.mapError(() => invalid("files"))
+  );
+});
+var folderSkillsEffect = (options) => Effect_exports.gen(function* () {
+  const path = options.path ?? "skills";
+  if (!Schema_exports.is(SkillFilePath)(path))
+    return yield* new SkillDefinitionInvalid({ file: "SKILL.md", reason: "directory" });
+  const files = yield* Schema_exports.decodeUnknownEffect(Schema_exports.Array(SkillFile))(options.files).pipe(
+    Effect_exports.mapError(() => new SkillDefinitionInvalid({ file: path, reason: "files" }))
+  );
+  const prefix = `${path}/`;
+  const directories = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    if (!file.path.startsWith(prefix)) continue;
+    const [name, ...relative] = file.path.slice(prefix.length).split("/");
+    if (relative.length === 0) continue;
+    if (name === void 0 || !Schema_exports.is(AppSkillName)(name))
+      return yield* new SkillDefinitionInvalid({ file: file.path, reason: "directory" });
+    const resource = { path: relative.join("/"), content: file.content };
+    const existing = directories.get(name);
+    if (existing === void 0) directories.set(name, [resource]);
+    else existing.push(resource);
+  }
+  return yield* Effect_exports.forEach(
+    [...directories].sort(([a], [b]) => a.localeCompare(b)),
+    ([name, files2]) => skillFromFiles(
+      files2.sort((a, b) => a.path.localeCompare(b.path)),
+      { name, directory: `${path}/${name}` }
+    )
+  );
+});
+
+export {
+  skillFromFiles,
+  folderSkillsEffect
+};