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

package/js/skills.js

@@ -0,0 +1,894 @@
+import {
+  catalogCache
+} from "./chunk-5MQZEB6Y.js";
+import "./chunk-D47C7KG5.js";
+import {
+  folderSkillsEffect,
+  skillFromFiles
+} from "./chunk-FDNTX5QJ.js";
+import {
+  httpProviderError
+} from "./chunk-ZJWDMTE3.js";
+import "./chunk-LGIYBDWA.js";
+import {
+  AppSkillMetadata,
+  AppSkillSource,
+  AppSkills,
+  SkillDefinitionInvalid,
+  SkillFilePath,
+  SkillLoadFailed,
+  SkillServiceName,
+  skillLoadLimits
+} from "./chunk-YEJOQEII.js";
+import "./chunk-W7D7WVSY.js";
+import {
+  FetchHttpClient_exports
+} from "./chunk-HDJH3RPR.js";
+import {
+  HttpBody_exports,
+  HttpClient_exports
+} from "./chunk-QKHR7BMF.js";
+import {
+  wrap
+} from "./chunk-WFSQXYUT.js";
+import "./chunk-SATWJKN6.js";
+import {
+  Effect_exports,
+  Ref_exports,
+  Schema_exports,
+  Stream_exports
+} from "./chunk-FW5HBOIK.js";
+import "./chunk-CZ7CSFO4.js";
+
+// src/implementation/inflate.ts
+var InflateError = class extends Error {
+};
+var InflateLimitExceeded = class extends Error {
+};
+var huffman = (lengths, offset, count) => {
+  const counts = new Uint16Array(16);
+  const symbols = new Uint16Array(count);
+  for (let index = 0; index < count; index++) counts[lengths[offset + index]]++;
+  counts[0] = 0;
+  const offsets = new Uint16Array(16);
+  for (let length = 1; length < 16; length++)
+    offsets[length] = offsets[length - 1] + counts[length - 1];
+  for (let index = 0; index < count; index++) {
+    const length = lengths[offset + index];
+    if (length !== 0) symbols[offsets[length]++] = index;
+  }
+  return { counts, symbols };
+};
+var lengthBase = [
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  11,
+  13,
+  15,
+  17,
+  19,
+  23,
+  27,
+  31,
+  35,
+  43,
+  51,
+  59,
+  67,
+  83,
+  99,
+  115,
+  131,
+  163,
+  195,
+  227,
+  258
+];
+var lengthExtra = [
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  2,
+  2,
+  2,
+  2,
+  3,
+  3,
+  3,
+  3,
+  4,
+  4,
+  4,
+  4,
+  5,
+  5,
+  5,
+  5,
+  0
+];
+var distanceBase = [
+  1,
+  2,
+  3,
+  4,
+  5,
+  7,
+  9,
+  13,
+  17,
+  25,
+  33,
+  49,
+  65,
+  97,
+  129,
+  193,
+  257,
+  385,
+  513,
+  769,
+  1025,
+  1537,
+  2049,
+  3073,
+  4097,
+  6145,
+  8193,
+  12289,
+  16385,
+  24577
+];
+var distanceExtra = [
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  2,
+  2,
+  3,
+  3,
+  4,
+  4,
+  5,
+  5,
+  6,
+  6,
+  7,
+  7,
+  8,
+  8,
+  9,
+  9,
+  10,
+  10,
+  11,
+  11,
+  12,
+  12,
+  13,
+  13
+];
+var codeLengthOrder = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
+var fixedLengths = new Uint8Array(288 + 30);
+fixedLengths.fill(8, 0, 144);
+fixedLengths.fill(9, 144, 256);
+fixedLengths.fill(7, 256, 280);
+fixedLengths.fill(8, 280, 288);
+fixedLengths.fill(5, 288, 318);
+var fixedLiteral = huffman(fixedLengths, 0, 288);
+var fixedDistance = huffman(fixedLengths, 288, 30);
+var inflateZlib = (input, start, limit) => {
+  if (start + 2 > input.byteLength) throw new InflateError("truncated header");
+  const cmf = input[start];
+  const flags = input[start + 1];
+  if ((cmf & 15) !== 8 || (cmf << 8 | flags) % 31 !== 0 || flags & 32)
+    throw new InflateError("invalid zlib header");
+  let position = start + 2;
+  let bitBuffer = 0;
+  let bitCount = 0;
+  let output = new Uint8Array(Math.min(limit, 1024));
+  let length = 0;
+  const bits = (count) => {
+    while (bitCount < count) {
+      if (position >= input.byteLength) throw new InflateError("truncated stream");
+      bitBuffer |= input[position++] << bitCount;
+      bitCount += 8;
+    }
+    const value = bitBuffer & (1 << count) - 1;
+    bitBuffer >>>= count;
+    bitCount -= count;
+    return value;
+  };
+  const decode = ({ counts, symbols }) => {
+    let code = 0;
+    let first = 0;
+    let index = 0;
+    for (let bitLength = 1; bitLength < 16; bitLength++) {
+      code |= bits(1);
+      const count = counts[bitLength];
+      if (code - count < first) return symbols[index + (code - first)];
+      index += count;
+      first += count;
+      first <<= 1;
+      code <<= 1;
+    }
+    throw new InflateError("invalid code");
+  };
+  const reserve = (extra) => {
+    if (length + extra > limit) throw new InflateLimitExceeded();
+    if (length + extra <= output.byteLength) return;
+    const next = new Uint8Array(Math.min(limit, Math.max(output.byteLength * 2, length + extra)));
+    next.set(output.subarray(0, length));
+    output = next;
+  };
+  const codes = (literal, distance) => {
+    for (; ; ) {
+      const symbol = decode(literal);
+      if (symbol < 256) {
+        reserve(1);
+        output[length++] = symbol;
+      } else if (symbol === 256) {
+        return;
+      } else {
+        const lengthIndex = symbol - 257;
+        if (lengthIndex >= 29) throw new InflateError("invalid length symbol");
+        const size = lengthBase[lengthIndex] + bits(lengthExtra[lengthIndex]);
+        const distanceIndex = decode(distance);
+        if (distanceIndex >= 30) throw new InflateError("invalid distance symbol");
+        const back = distanceBase[distanceIndex] + bits(distanceExtra[distanceIndex]);
+        if (back > length) throw new InflateError("distance too far back");
+        reserve(size);
+        for (let copied = 0; copied < size; copied++, length++)
+          output[length] = output[length - back];
+      }
+    }
+  };
+  let last = 0;
+  while (!last) {
+    last = bits(1);
+    const type = bits(2);
+    if (type === 0) {
+      bitBuffer = 0;
+      bitCount = 0;
+      if (position + 4 > input.byteLength) throw new InflateError("truncated stored block");
+      const size = input[position] | input[position + 1] << 8;
+      const complement = input[position + 2] | input[position + 3] << 8;
+      if ((size ^ 65535) !== complement) throw new InflateError("invalid stored block");
+      position += 4;
+      if (position + size > input.byteLength) throw new InflateError("truncated stored block");
+      reserve(size);
+      output.set(input.subarray(position, position + size), length);
+      length += size;
+      position += size;
+    } else if (type === 1) {
+      codes(fixedLiteral, fixedDistance);
+    } else if (type === 2) {
+      const literalCount = bits(5) + 257;
+      const distanceCount = bits(5) + 1;
+      const codeLengthCount = bits(4) + 4;
+      const codeLengths = new Uint8Array(19);
+      for (let index = 0; index < codeLengthCount; index++)
+        codeLengths[codeLengthOrder[index]] = bits(3);
+      const codeLengthCode = huffman(codeLengths, 0, 19);
+      const lengths = new Uint8Array(literalCount + distanceCount);
+      for (let index = 0; index < lengths.byteLength; ) {
+        const symbol = decode(codeLengthCode);
+        if (symbol < 16) {
+          lengths[index++] = symbol;
+          continue;
+        }
+        let repeat;
+        let value = 0;
+        if (symbol === 16) {
+          if (index === 0) throw new InflateError("repeat without length");
+          value = lengths[index - 1];
+          repeat = 3 + bits(2);
+        } else if (symbol === 17) repeat = 3 + bits(3);
+        else repeat = 11 + bits(7);
+        if (index + repeat > lengths.byteLength) throw new InflateError("too many lengths");
+        lengths.fill(value, index, index + repeat);
+        index += repeat;
+      }
+      codes(huffman(lengths, 0, literalCount), huffman(lengths, literalCount, distanceCount));
+    } else {
+      throw new InflateError("invalid block type");
+    }
+  }
+  if (position + 4 > input.byteLength) throw new InflateError("truncated checksum");
+  const data = output.subarray(0, length);
+  let a = 1;
+  let b = 0;
+  for (let index = 0; index < data.byteLength; index++) {
+    a = (a + data[index]) % 65521;
+    b = (b + a) % 65521;
+  }
+  const expected = (input[position] << 24 | input[position + 1] << 16 | input[position + 2] << 8 | input[position + 3]) >>> 0;
+  if ((b << 16 | a) >>> 0 !== expected) throw new InflateError("checksum mismatch");
+  return { data, end: position + 4 };
+};
+
+// src/implementation/git.ts
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+var GitProtocolError = class extends Error {
+};
+var pkt = (line) => {
+  const bytes = encoder.encode(line);
+  return [...encoder.encode((bytes.byteLength + 4).toString(16).padStart(4, "0")), ...bytes];
+};
+var flush = [...encoder.encode("0000")];
+var delimiter = [...encoder.encode("0001")];
+var packets = (bytes) => {
+  const lines = [];
+  for (let at = 0; at < bytes.byteLength; ) {
+    if (at + 4 > bytes.byteLength) throw new GitProtocolError("truncated packet");
+    const size = Number.parseInt(decoder.decode(bytes.subarray(at, at + 4)), 16);
+    if (!Number.isInteger(size) || size === 3 || at + Math.max(size, 4) > bytes.byteLength)
+      throw new GitProtocolError("invalid packet length");
+    if (size < 4) {
+      lines.push("boundary");
+      at += 4;
+      continue;
+    }
+    lines.push(bytes.subarray(at + 4, at + size));
+    at += size;
+  }
+  return lines;
+};
+var gitRequestHeaders = {
+  "Content-Type": "application/x-git-upload-pack-request",
+  "Git-Protocol": "version=2"
+};
+var refCandidates = (ref) => ref === void 0 || ref === "HEAD" ? ["HEAD"] : [`refs/heads/${ref}`, `refs/tags/${ref}`];
+var lsRefsRequest = (names) => new Uint8Array([
+  ...pkt("command=ls-refs\n"),
+  ...delimiter,
+  ...pkt("peel\n"),
+  ...names.flatMap((name) => pkt(`ref-prefix ${name}
+`)),
+  ...flush
+]);
+var parseLsRefs = (bytes) => {
+  const refs = /* @__PURE__ */ new Map();
+  for (const line of packets(bytes)) {
+    if (line === "boundary") continue;
+    const match = /^([a-f0-9]{40}) (\S+)(?: .*?peeled:([a-f0-9]{40}))?/.exec(decoder.decode(line));
+    if (match !== null) refs.set(match[2], match[3] ?? match[1]);
+  }
+  return refs;
+};
+var treeFetchRequest = (commit) => new Uint8Array([
+  ...pkt("command=fetch\n"),
+  ...delimiter,
+  ...pkt("no-progress\n"),
+  ...pkt("ofs-delta\n"),
+  ...pkt("deepen 1\n"),
+  ...pkt("filter blob:none\n"),
+  ...pkt(`want ${commit}
+`),
+  ...pkt("done\n"),
+  ...flush
+]);
+var packfile = (bytes) => {
+  const chunks = [];
+  let inPack = false;
+  for (const line of packets(bytes)) {
+    if (line === "boundary") continue;
+    if (!inPack) {
+      inPack = decoder.decode(line) === "packfile\n";
+      continue;
+    }
+    if (line[0] === 1) chunks.push(line.subarray(1));
+    else if (line[0] === 3) throw new GitProtocolError("remote error");
+  }
+  if (!inPack) throw new GitProtocolError("missing packfile");
+  const pack = new Uint8Array(chunks.reduce((size, chunk) => size + chunk.byteLength, 0));
+  let offset = 0;
+  for (const chunk of chunks) {
+    pack.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return pack;
+};
+var objectTypes = { 1: "commit", 2: "tree", 3: "blob", 4: "tag" };
+var applyDelta = (base, delta) => {
+  let at = 0;
+  const size = () => {
+    let value = 0;
+    let shift = 0;
+    let byte;
+    do {
+      if (at >= delta.byteLength) throw new GitProtocolError("truncated delta");
+      byte = delta[at++];
+      value += (byte & 127) * 2 ** shift;
+      shift += 7;
+    } while (byte & 128);
+    return value;
+  };
+  if (size() !== base.byteLength) throw new GitProtocolError("delta base size mismatch");
+  const result = new Uint8Array(size());
+  let length = 0;
+  while (at < delta.byteLength) {
+    const op = delta[at++];
+    if (op & 128) {
+      let offset = 0;
+      let count = 0;
+      for (let bit = 0; bit < 4; bit++)
+        if (op & 1 << bit) offset += delta[at++] * 2 ** (8 * bit);
+      for (let bit = 0; bit < 3; bit++)
+        if (op & 1 << 4 + bit) count += delta[at++] * 2 ** (8 * bit);
+      if (count === 0) count = 65536;
+      if (offset + count > base.byteLength || length + count > result.byteLength)
+        throw new GitProtocolError("invalid delta copy");
+      result.set(base.subarray(offset, offset + count), length);
+      length += count;
+    } else if (op !== 0) {
+      if (at + op > delta.byteLength || length + op > result.byteLength)
+        throw new GitProtocolError("invalid delta insert");
+      result.set(delta.subarray(at, at + op), length);
+      length += op;
+      at += op;
+    } else {
+      throw new GitProtocolError("reserved delta opcode");
+    }
+  }
+  if (length !== result.byteLength) throw new GitProtocolError("delta size mismatch");
+  return result;
+};
+var hex = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+var objectId = async (type, data) => {
+  const header = encoder.encode(`${type} ${data.byteLength}\0`);
+  const whole = new Uint8Array(header.byteLength + data.byteLength);
+  whole.set(header);
+  whole.set(data, header.byteLength);
+  return hex(new Uint8Array(await crypto.subtle.digest("SHA-1", whole)));
+};
+var unpack = async (pack, limits) => {
+  if (decoder.decode(pack.subarray(0, 4)) !== "PACK" || pack.byteLength < 32)
+    throw new GitProtocolError("invalid packfile");
+  const view = new DataView(pack.buffer, pack.byteOffset, pack.byteLength);
+  const version = view.getUint32(4);
+  if (version !== 2 && version !== 3) throw new GitProtocolError("unsupported packfile version");
+  const count = view.getUint32(8);
+  const entries = /* @__PURE__ */ new Map();
+  let at = 12;
+  for (let index = 0; index < count; index++) {
+    const start = at;
+    let byte = pack[at++];
+    const code = byte >> 4 & 7;
+    while (byte & 128) byte = pack[at++];
+    if (code === 6) {
+      byte = pack[at++];
+      let back = byte & 127;
+      while (byte & 128) {
+        byte = pack[at++];
+        back = (back + 1) * 128 + (byte & 127);
+      }
+      const { data, end } = inflateZlib(pack, at, limits.objectBytes);
+      entries.set(start, { kind: "offset", base: start - back, delta: data });
+      at = end;
+    } else if (code === 7) {
+      const base = hex(pack.subarray(at, at + 20));
+      const { data, end } = inflateZlib(pack, at + 20, limits.objectBytes);
+      entries.set(start, { kind: "reference", base, delta: data });
+      at = end;
+    } else {
+      const type = objectTypes[code];
+      if (type === void 0) throw new GitProtocolError("invalid object type");
+      const { data, end } = inflateZlib(pack, at, limits.objectBytes);
+      entries.set(start, { kind: "whole", type, data });
+      at = end;
+    }
+    if (at > pack.byteLength) throw new GitProtocolError("truncated packfile");
+  }
+  const objects = /* @__PURE__ */ new Map();
+  const resolved = /* @__PURE__ */ new Map();
+  const pending = new Set(entries.keys());
+  while (pending.size > 0) {
+    let progressed = false;
+    for (const offset of pending) {
+      const entry = entries.get(offset);
+      let object;
+      if (entry.kind === "whole") object = entry;
+      else {
+        const base = entry.kind === "offset" ? resolved.get(entry.base) : objects.get(entry.base);
+        if (base !== void 0)
+          object = { type: base.type, data: applyDelta(base.data, entry.delta) };
+      }
+      if (object === void 0) continue;
+      resolved.set(offset, object);
+      objects.set(await objectId(object.type, object.data), object);
+      pending.delete(offset);
+      progressed = true;
+    }
+    if (!progressed) throw new GitProtocolError("unresolved delta base");
+  }
+  return objects;
+};
+var parseTreeFetch = async (bytes, commit, path, limits) => {
+  const objects = await unpack(packfile(bytes), limits);
+  const head = objects.get(commit);
+  if (head?.type !== "commit") throw new GitProtocolError("missing commit");
+  const root = /^tree ([a-f0-9]{40})$/m.exec(decoder.decode(head.data))?.[1];
+  if (root === void 0) throw new GitProtocolError("commit without tree");
+  const entries = (tree) => {
+    const object = objects.get(tree);
+    if (object?.type !== "tree") throw new GitProtocolError("missing tree");
+    const result = [];
+    for (let at = 0; at < object.data.byteLength; ) {
+      const space = object.data.indexOf(32, at);
+      const nul = object.data.indexOf(0, space);
+      if (space < 0 || nul < 0 || nul + 21 > object.data.byteLength)
+        throw new GitProtocolError("invalid tree entry");
+      result.push({
+        mode: decoder.decode(object.data.subarray(at, space)).padStart(6, "0"),
+        name: decoder.decode(object.data.subarray(space + 1, nul)),
+        id: hex(object.data.subarray(nul + 1, nul + 21))
+      });
+      at = nul + 21;
+    }
+    return result;
+  };
+  let start = root;
+  const prefix = path === void 0 ? [] : path.split("/");
+  for (const name of prefix) {
+    const next = entries(start).find((entry) => entry.name === name && entry.mode === "040000");
+    if (next === void 0) return [];
+    start = next.id;
+  }
+  const files = [];
+  const walk = (tree, directory) => {
+    for (const entry of entries(tree)) {
+      const entryPath = `${directory}${entry.name}`;
+      if (entry.mode === "040000") walk(entry.id, `${entryPath}/`);
+      else if (entry.mode !== "160000") {
+        files.push({ path: entryPath, mode: entry.mode });
+      }
+    }
+  };
+  walk(start, prefix.length === 0 ? "" : `${prefix.join("/")}/`);
+  return files;
+};
+
+// src/implementation/skills.ts
+var failed = (reason) => new SkillLoadFailed({ reason });
+var rejected = (status, headers) => new SkillLoadFailed({
+  reason: httpProviderError(status, headers)?.reason === "rate_limited" ? "rate_limited" : "request",
+  status
+});
+var describe = (service, { reason, status }) => {
+  switch (reason) {
+    case "rate_limited":
+      return `${service} is rate limiting skill requests (HTTP ${status}).`;
+    case "request":
+      return status === void 0 ? `Could not reach ${service} to load skills.` : `${service} returned HTTP ${status} while loading skills.`;
+    case "source":
+      return `The ${service} skill source settings are not valid.`;
+    case "document":
+      return `A skill from ${service} is not a valid skill document.`;
+    case "limit":
+      return `The skills from ${service} exceed Executor\u2019s file or size limits.`;
+    case "changed":
+      return `The skills on ${service} changed while they were being read.`;
+    case "encoding":
+      return `A skill file from ${service} is not valid UTF-8 text.`;
+  }
+};
+var withService = (service) => (effect) => service === void 0 || !Schema_exports.is(SkillServiceName)(service) ? effect : effect.pipe(
+  Effect_exports.mapError(
+    (error) => !error.message ? new SkillLoadFailed({
+      reason: error.reason,
+      message: describe(service, error),
+      ...error.status === void 0 ? {} : { status: error.status }
+    }) : error
+  )
+);
+var parse = (schema, input) => Schema_exports.decodeUnknownEffect(schema)(input).pipe(Effect_exports.mapError(() => failed("document")));
+var resourcePath = (path) => {
+  if (!Schema_exports.is(SkillFilePath)(path)) return false;
+  try {
+    return path.split("/").every((part) => {
+      const decoded = decodeURIComponent(part);
+      return decoded !== "." && decoded !== ".." && !/[\\/]/.test(decoded) && !decoded.includes("\0");
+    });
+  } catch {
+    return false;
+  }
+};
+var pathUrl = (base, path) => new URL(path.split("/").map(encodeURIComponent).join("/"), base).href;
+var reader = (transport) => Effect_exports.gen(function* () {
+  const budget = yield* Ref_exports.make(0);
+  const fetchBytes = (url, post) => Effect_exports.gen(function* () {
+    const parsed = yield* Effect_exports.try({
+      try: () => new URL(url),
+      catch: () => failed("source")
+    });
+    if (!["https:", "http:"].includes(parsed.protocol) || parsed.username || parsed.password || parsed.hash)
+      return yield* failed("source");
+    const client = HttpClient_exports.withScope(yield* HttpClient_exports.HttpClient);
+    const headers = {
+      "User-Agent": "executor-skills",
+      Accept: "application/json, text/plain",
+      "Cache-Control": "no-cache"
+    };
+    const response = yield* (post === void 0 ? client.get(parsed, { headers }) : client.post(parsed, {
+      headers: { ...headers, ...post.headers },
+      body: HttpBody_exports.uint8Array(post.body, post.headers["Content-Type"])
+    })).pipe(Effect_exports.mapError(() => failed("request")));
+    if (response.status < 200 || response.status >= 300)
+      return yield* rejected(response.status, response.headers);
+    const chunks = [];
+    let size = 0;
+    yield* response.stream.pipe(
+      Stream_exports.mapError(() => failed("request")),
+      Stream_exports.runForEach(
+        (chunk) => Effect_exports.gen(function* () {
+          size += chunk.byteLength;
+          const total = yield* Ref_exports.updateAndGet(budget, (total2) => total2 + chunk.byteLength);
+          if (size > skillLoadLimits.fileBytes || total > skillLoadLimits.totalBytes)
+            return yield* failed("limit");
+          chunks.push(chunk);
+        })
+      )
+    );
+    const result = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return result;
+  }).pipe(
+    Effect_exports.scoped,
+    Effect_exports.provide(FetchHttpClient_exports.layer),
+    Effect_exports.provideService(FetchHttpClient_exports.RequestInit, { redirect: "manual" }),
+    Effect_exports.provideService(FetchHttpClient_exports.Fetch, transport.fetch ?? globalThis.fetch)
+  );
+  const read = (url) => fetchBytes(url).pipe(
+    Effect_exports.flatMap(
+      (result) => Effect_exports.try({
+        try: () => new TextDecoder("utf-8", { fatal: true }).decode(result),
+        catch: () => failed("encoding")
+      })
+    )
+  );
+  const json = (url) => read(url).pipe(Effect_exports.flatMap((text) => parse(Schema_exports.fromJsonString(Schema_exports.Unknown), text)));
+  return { fetchBytes, read, json };
+});
+var unreadable = () => new SkillLoadFailed({
+  reason: "request",
+  message: "GitHub returned a git response Executor could not read."
+});
+var git = (run) => Effect_exports.tryPromise({
+  try: async () => run(),
+  catch: (error) => error instanceof InflateLimitExceeded ? failed("limit") : unreadable()
+});
+var resolveCommit = (remote, repo, ref) => Effect_exports.gen(function* () {
+  if (ref !== void 0 && /^[a-f0-9]{40}$/.test(ref)) return ref;
+  const names = refCandidates(ref);
+  const response = yield* remote.fetchBytes(`https://github.com/${repo}.git/git-upload-pack`, {
+    body: lsRefsRequest(names),
+    headers: gitRequestHeaders
+  }).pipe(
+    // GitHub asks for credentials when a repository is missing or private.
+    Effect_exports.mapError(
+      (error) => error.status === 401 || error.status === 404 ? new SkillLoadFailed({
+        reason: "source",
+        message: `GitHub has no public repository named ${repo}.`,
+        status: error.status
+      }) : error
+    )
+  );
+  const refs = yield* git(() => parseLsRefs(response));
+  const commit = names.map((name) => refs.get(name)).find((sha) => sha !== void 0);
+  if (commit === void 0)
+    return yield* new SkillLoadFailed({
+      reason: "source",
+      message: `GitHub repository ${repo} has no branch or tag named ${ref}.`
+    });
+  return commit;
+});
+var listFiles = (remote, repo, commit, path) => remote.fetchBytes(`https://github.com/${repo}.git/git-upload-pack`, {
+  body: treeFetchRequest(commit),
+  headers: gitRequestHeaders
+}).pipe(
+  Effect_exports.flatMap(
+    (response) => git(
+      () => parseTreeFetch(response, commit, path, { objectBytes: skillLoadLimits.fileBytes })
+    )
+  )
+);
+var SkillDirectories = Schema_exports.Array(
+  Schema_exports.Struct({
+    directory: Schema_exports.String,
+    files: Schema_exports.Array(Schema_exports.Struct({ path: Schema_exports.String, mode: Schema_exports.String }))
+  })
+);
+var skillDirectories = (remote, repo, commit, path) => Effect_exports.gen(function* () {
+  const files = yield* listFiles(remote, repo, commit, path);
+  const documents = files.filter(
+    (file) => file.path === "SKILL.md" || file.path.endsWith("/SKILL.md")
+  );
+  const directories = documents.map((document) => {
+    const directory = document.path.slice(0, -"SKILL.md".length);
+    return { directory, files: files.filter((file) => file.path.startsWith(directory)) };
+  });
+  if (directories.reduce((count, item) => count + item.files.length, 0) > skillLoadLimits.files)
+    return yield* failed("limit");
+  return directories;
+});
+var cachedSkillDirectories = (cache, transport, repo, commit, path) => Effect_exports.tryPromise({
+  try: () => cache.get({
+    key: ["apps/githubSkills/directories", 1, repo, commit, path ?? null],
+    schema: wrap(SkillDirectories, false),
+    freshFor: "7 days",
+    load: (context) => Effect_exports.runPromise(
+      // Keep the author's fetch, as every other read in this load does.
+      reader({ fetch: transport.fetch, signal: context.signal }).pipe(
+        Effect_exports.flatMap((remote) => skillDirectories(remote, repo, commit, path))
+      ),
+      { signal: context.signal }
+    )
+  }),
+  catch: (error) => Schema_exports.is(SkillLoadFailed)(error) ? error : new SkillLoadFailed({
+    reason: "request",
+    message: "Executor could not read or update the app cache for skills."
+  })
+});
+var cachedCatalog = (options, prefix, load) => options.cache === void 0 ? load(options, void 0) : catalogCache({
+  cache: options.cache,
+  ...options.freshFor === void 0 ? {} : { freshFor: options.freshFor },
+  ...options.staleFor === void 0 ? {} : { staleFor: options.staleFor },
+  prefix,
+  schema: AppSkillSource,
+  summary: { schema: AppSkillMetadata, of: ({ files: _files, ...metadata }) => metadata },
+  load: (context) => context === void 0 ? load(options, options.cache) : load({ fetch: options.fetch, signal: context.signal }, context.cache)
+}).pipe(
+  Effect_exports.flatMap((catalog) => catalog.list()),
+  Effect_exports.mapError(
+    (error) => Schema_exports.is(SkillLoadFailed)(error) ? error : new SkillLoadFailed({
+      reason: "request",
+      message: "Executor could not read or update the app cache for skills."
+    })
+  )
+);
+var githubSkillsEffect = (options) => Effect_exports.gen(function* () {
+  if (!/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(options.repo) || options.path !== void 0 && !resourcePath(options.path))
+    return yield* failed("source");
+  return yield* cachedCatalog(
+    options,
+    ["apps/githubSkills/catalog", 1, options.repo, options.ref ?? null, options.path ?? null],
+    (transport, cache) => githubCatalog(options, transport, cache)
+  );
+}).pipe(withService("GitHub"));
+var githubCatalog = (options, transport, cache) => Effect_exports.gen(function* () {
+  const remote = yield* reader(transport);
+  const commit = yield* resolveCommit(remote, options.repo, options.ref);
+  const resources = yield* cache === void 0 ? skillDirectories(remote, options.repo, commit, options.path) : cachedSkillDirectories(cache, transport, options.repo, commit, options.path);
+  const base = `https://raw.githubusercontent.com/${options.repo}/${commit}/`;
+  const skills = yield* Effect_exports.forEach(
+    resources,
+    ({ directory, files }) => Effect_exports.gen(function* () {
+      const sources = yield* Effect_exports.forEach(
+        files,
+        (file) => Effect_exports.gen(function* () {
+          const path = file.path.slice(directory.length);
+          if (!resourcePath(file.path) || !resourcePath(path) || file.mode === "120000")
+            return yield* failed("source");
+          return { path, content: yield* remote.read(pathUrl(base, file.path)) };
+        }),
+        { concurrency: skillLoadLimits.concurrency }
+      );
+      const name = directory.slice(0, -1).split("/").at(-1);
+      return yield* skillFromFiles(
+        sources,
+        directory === "" || name === void 0 ? {} : { name }
+      ).pipe(Effect_exports.mapError(() => failed("document")));
+    }),
+    { concurrency: 1 }
+  );
+  return yield* parse(AppSkills, skills);
+});
+var Index = Schema_exports.Struct({
+  skills: Schema_exports.Array(
+    Schema_exports.Struct({
+      name: AppSkillMetadata.fields.name,
+      version: Schema_exports.optionalKey(Schema_exports.String),
+      files: Schema_exports.Array(Schema_exports.String)
+    })
+  )
+});
+var wellKnownSkillsEffect = (options) => Effect_exports.gen(function* () {
+  const url = yield* Effect_exports.try({
+    try: () => new URL(options.url),
+    catch: () => failed("source")
+  });
+  if (url.pathname === "/") url.pathname = "/.well-known/agent-skills/index.json";
+  else if (!url.pathname.endsWith("index.json"))
+    url.pathname = `${url.pathname.replace(/\/$/, "")}/index.json`;
+  return yield* cachedCatalog(
+    options,
+    ["apps/wellKnownSkills/catalog", 1, url.href],
+    (transport) => wellKnownCatalog(url, transport)
+  );
+}).pipe(withService(URL.canParse(options.url) ? new URL(options.url).hostname : void 0));
+var wellKnownCatalog = (url, transport) => Effect_exports.gen(function* () {
+  const remote = yield* reader(transport);
+  const first = yield* remote.read(url.href);
+  const index = yield* parse(Schema_exports.fromJsonString(Index), first);
+  if (index.skills.reduce((count, skill) => count + skill.files.length, 0) > skillLoadLimits.files)
+    return yield* failed("limit");
+  const skills = yield* Effect_exports.forEach(
+    index.skills,
+    (entry) => Effect_exports.gen(function* () {
+      const base = new URL(`${encodeURIComponent(entry.name)}/`, url).href;
+      const files = yield* Effect_exports.forEach(
+        entry.files,
+        (path) => Effect_exports.gen(function* () {
+          if (!resourcePath(path)) return yield* failed("source");
+          return { path, content: yield* remote.read(pathUrl(base, path)) };
+        }),
+        { concurrency: skillLoadLimits.concurrency }
+      );
+      return yield* skillFromFiles(files, { name: entry.name }).pipe(
+        Effect_exports.mapError(() => failed("document"))
+      );
+    }),
+    { concurrency: 1 }
+  );
+  if ((yield* remote.read(url.href)) !== first) return yield* failed("changed");
+  return yield* parse(AppSkills, skills);
+});
+
+// src/skills.ts
+var githubSkills = (options) => Effect_exports.runPromise(
+  githubSkillsEffect(options),
+  options.signal === void 0 ? {} : { signal: options.signal }
+);
+var wellKnownSkills = (options) => Effect_exports.runPromise(
+  wellKnownSkillsEffect(options),
+  options.signal === void 0 ? {} : { signal: options.signal }
+);
+var fileSkill = (files) => Effect_exports.runPromise(skillFromFiles(files));
+var folderSkills = (options) => Effect_exports.runPromise(folderSkillsEffect(options));
+var skillReader = (options) => {
+  const service = Schema_exports.decodeUnknownSync(SkillServiceName)(options.service);
+  const remote = Effect_exports.runSync(reader(options));
+  const run = (effect) => Effect_exports.runPromise(
+    effect.pipe(withService(service)),
+    options.signal === void 0 ? {} : { signal: options.signal }
+  );
+  return {
+    /** Fetch one UTF-8 text file. */
+    text: (url) => run(remote.read(url)),
+    /** Fetch and parse one JSON document. */
+    json: (url) => run(remote.json(url))
+  };
+};
+export {
+  SkillDefinitionInvalid,
+  SkillLoadFailed,
+  SkillServiceName,
+  fileSkill,
+  folderSkills,
+  githubSkills,
+  skillReader,
+  wellKnownSkills
+};