@opencode-ai/core 0.0.0-beta-19086 → 0.0.0-beta-19129

package/dist/chunks/{schema-gtyed076.js → pty-2aqpvcef.js}

@@ -1,30 +1,31 @@
 import {
-  exports_models
-} from "./schema-dwvtf5ds.js";
+  ID18,
+  aisdk2,
+  mergeOverlay2
+} from "./pty-tdt6s1r3.js";
 import {
-  exports_catalog
-} from "./schema-32ypdbhb.js";
+  ID11
+} from "./pty-0ywnm299.js";
 import {
-  exports_integration
-} from "./schema-b9bp1awf.js";
+  Service79
+} from "./pty-y974v3mv.js";
 import {
-  exports_app
-} from "./schema-hs51b0fc.js";
+  OAuth3,
+  Event16
+} from "./pty-bzq1f2yq.js";
 import {
-  exports_model
-} from "./schema-8manx9kj.js";
+  ID5,
+  MethodID2
+} from "./pty-pk02mbyy.js";
 import {
-  exports_provider
-} from "./schema-68yag814.js";
+  Service48
+} from "./pty-vrktewq8.js";
 import {
-  exports_credential
-} from "./schema-jgzett5g.js";
+  get2
+} from "./pty-ytrgf914.js";
 import {
-  exports_bus
-} from "./schema-fjb24bmd.js";
-import {
-  __require
-} from "./schema-vpjkya7h.js";
+  useragent2
+} from "./pty-vkpagyjs.js";
 
 // src/plugin/provider/github-copilot.ts
 import { Effect, Option, Schema, Semaphore, Stream } from "effect";
@@ -33,7 +34,7 @@ var clientID = "Ov23li8tweQw6odWQebz";
 var apiVersion = "2026-08-01";
 var userApiVersion = "2025-04-01";
 var pollingSafetyMargin = 3000;
-var methodID = exports_integration.MethodID.make("device");
+var methodID = MethodID2.make("device");
 var Device = Schema.Struct({
   verification_uri: Schema.String,
   user_code: Schema.String,
@@ -56,7 +57,7 @@ var decodeUser = Schema.decodeUnknownOption(User);
 var JsonBody = Schema.fromJsonString(Schema.Unknown);
 var decodeBody = Schema.decodeUnknownOption(JsonBody);
 var oauth = (app) => ({
-  integrationID: exports_integration.ID.make("github-copilot"),
+  integrationID: ID5.make("github-copilot"),
   method: {
     id: methodID,
     type: "oauth",
@@ -110,17 +111,17 @@ var oauth = (app) => ({
           headers: {
             Accept: "application/json",
             Authorization: `Bearer ${access}`,
-            "User-Agent": exports_app.useragent(app),
+            "User-Agent": useragent2(app),
             "X-GitHub-Api-Version": userApiVersion
           }
         }).pipe(Effect.map((user) => Option.getOrUndefined(decodeUser(user))), Effect.orElseSucceed(() => {
           return;
         }), Effect.flatMap((user) => {
-          const denied = user && copilotEntitlementError(user);
+          const denied = user && copilotEntitlementError2(user);
           if (denied)
             return Effect.fail(new Error(denied));
           const apiEndpoint = user?.endpoints?.api?.replace(/\/+$/, "");
-          return Effect.succeed(exports_credential.OAuth.make({
+          return Effect.succeed(OAuth3.make({
             type: "oauth",
             methodID,
             refresh: access,
@@ -151,11 +152,11 @@ var oauth = (app) => ({
     };
   })
 });
-var GithubCopilotPlugin = define({
+var GithubCopilotPlugin2 = define({
   id: "opencode.provider.github.copilot",
   effect: Effect.fn(function* (ctx) {
-    const catalog = yield* exports_catalog.Service;
-    const bus = yield* exports_bus.Service;
+    const catalog = yield* Service48;
+    const bus = yield* Service79;
     const loading = Semaphore.makeUnsafe(1);
     const loaded = {};
     const load = Effect.fn("GithubCopilotPlugin.load")(function* () {
@@ -168,14 +169,14 @@ var GithubCopilotPlugin = define({
         loaded.models = undefined;
         return;
       }
-      loaded.baseURL = copilotBaseURL(credential.metadata);
-      const provider = yield* catalog.provider.get(exports_provider.ID.githubCopilot);
-      const existing = (yield* catalog.model.all()).filter((model) => model.providerID === exports_provider.ID.githubCopilot);
+      loaded.baseURL = copilotBaseURL2(credential.metadata);
+      const provider = yield* catalog.provider.get(ID18.githubCopilot);
+      const existing = (yield* catalog.model.all()).filter((model) => model.providerID === ID18.githubCopilot);
       loaded.models = yield* Effect.tryPromise({
-        try: () => exports_models.get(loaded.baseURL ?? baseURL(), {
+        try: () => get2(loaded.baseURL ?? baseURL(), {
           ...provider?.headers,
           Authorization: `Bearer ${credential.refresh}`,
-          "User-Agent": exports_app.useragent(ctx.app),
+          "User-Agent": useragent2(ctx.app),
           "X-GitHub-Api-Version": apiVersion
         }, existing),
         catch: (cause) => cause
@@ -186,12 +187,12 @@ var GithubCopilotPlugin = define({
       editor.method.update(oauth(ctx.app));
     });
     yield* ctx.catalog.transform((evt) => {
-      const item = evt.provider.get(exports_provider.ID.githubCopilot);
+      const item = evt.provider.get(ID18.githubCopilot);
       if (!item)
         return;
       if (loaded.models) {
         for (const id of item.models.keys()) {
-          if (!loaded.models.has(exports_model.ID.make(id)))
+          if (!loaded.models.has(ID11.make(id)))
             evt.model.remove(item.provider.id, id);
         }
         for (const [id, model] of loaded.models) {
@@ -200,43 +201,43 @@ var GithubCopilotPlugin = define({
       } else {
         for (const id of item.models.keys()) {
           evt.model.update(item.provider.id, id, (model) => {
-            model.package = exports_provider.aisdk("@ai-sdk/github-copilot");
+            model.package = aisdk2("@ai-sdk/github-copilot");
             if (loaded.baseURL)
-              model.settings = exports_provider.mergeOverlay(model.settings, { baseURL: loaded.baseURL });
+              model.settings = mergeOverlay2(model.settings, { baseURL: loaded.baseURL });
           });
         }
       }
-      if (item.models.has(exports_model.ID.make("gpt-5-chat-latest"))) {
-        evt.model.update(item.provider.id, exports_model.ID.make("gpt-5-chat-latest"), (model) => {
+      if (item.models.has(ID11.make("gpt-5-chat-latest"))) {
+        evt.model.update(item.provider.id, ID11.make("gpt-5-chat-latest"), (model) => {
           model.enabled = false;
         });
       }
     });
     const refresh = () => loading.withPermit(load().pipe(Effect.andThen(ctx.catalog.reload())));
-    yield* bus.subscribe(exports_credential.Event.Switched).pipe(Stream.filter((event) => event.data.integrationID === exports_integration.ID.make("github-copilot")), Stream.runForEach(refresh), Effect.forkScoped({ startImmediately: true }));
+    yield* bus.subscribe(Event16.Switched).pipe(Stream.filter((event) => event.data.integrationID === ID5.make("github-copilot")), Stream.runForEach(refresh), Effect.forkScoped({ startImmediately: true }));
     yield* refresh().pipe(Effect.forkScoped);
     yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
-      if (evt.model.providerID !== exports_provider.ID.githubCopilot)
+      if (evt.model.providerID !== ID18.githubCopilot)
         return;
       if (evt.package !== "@ai-sdk/github-copilot")
         return;
-      evt.options.fetch = copilotFetch(typeof evt.options.apiKey === "string" ? evt.options.apiKey : undefined, evt.options.fetch, ctx.app);
+      evt.options.fetch = copilotFetch2(typeof evt.options.apiKey === "string" ? evt.options.apiKey : undefined, evt.options.fetch, ctx.app);
       const mod = yield* Effect.promise(() => import("../github-copilot/copilot-provider.js"));
       evt.sdk = mod.createOpenaiCompatible(evt.options);
     }));
     yield* ctx.session.hook("model.request", (evt) => Effect.gen(function* () {
-      if (evt.model.providerID !== exports_provider.ID.githubCopilot)
+      if (evt.model.providerID !== ID18.githubCopilot)
         return;
       const session = yield* ctx.session.get({ sessionID: evt.sessionID }).pipe(Effect.orElseSucceed(() => {
         return;
       }));
-      const interaction = interactionType(evt.kind, session?.parentID !== undefined);
+      const interaction = interactionType2(evt.kind, session?.parentID !== undefined);
       evt.headers["X-Interaction-Type"] = interaction;
       if (interaction !== "conversation-agent")
         evt.headers["x-initiator"] = "agent";
-    }), { providerID: exports_provider.ID.githubCopilot });
+    }), { providerID: ID18.githubCopilot });
     yield* ctx.session.hook("http.request", (evt) => Effect.gen(function* () {
-      if (evt.model.providerID !== exports_provider.ID.githubCopilot)
+      if (evt.model.providerID !== ID18.githubCopilot)
         return;
       const token = evt.request.headers.get("x-api-key");
       if (!token)
@@ -244,9 +245,9 @@ var GithubCopilotPlugin = define({
       const text = yield* Effect.promise(() => evt.request.clone().text());
       const body = Option.getOrUndefined(decodeBody(text));
       applyHeaders(evt.request.headers, token, ctx.app, requestMetadata(evt.request.url, body), true);
-    }), { providerID: exports_provider.ID.githubCopilot });
+    }), { providerID: ID18.githubCopilot });
     yield* ctx.aisdk.hook("language", Effect.fn(function* (evt) {
-      if (evt.model.providerID !== exports_provider.ID.githubCopilot)
+      if (evt.model.providerID !== ID18.githubCopilot)
         return;
       if (evt.sdk.responses === undefined && evt.sdk.chat === undefined) {
         evt.language = evt.sdk.languageModel(evt.model.modelID ?? evt.model.id);
@@ -278,14 +279,14 @@ function oauthURLs(domain) {
 function baseURL(enterprise) {
   return enterprise ? `https://copilot-api.${normalizeDomain(enterprise)}` : "https://api.githubcopilot.com";
 }
-function copilotEntitlementError(user) {
+function copilotEntitlementError2(user) {
   if (user.chat_enabled !== false)
     return;
   if (user.can_signup_for_limited)
     return "This GitHub account is not signed up for GitHub Copilot. Sign up for Copilot Free at https://github.com/features/copilot/plans and connect again.";
   return "This GitHub account does not have GitHub Copilot access. It needs an active Copilot subscription or a seat assigned by an organization.";
 }
-function copilotBaseURL(metadata) {
+function copilotBaseURL2(metadata) {
   const endpoint = metadata?.apiEndpoint;
   if (typeof endpoint === "string" && endpoint)
     return endpoint;
@@ -296,7 +297,7 @@ function headers(app) {
   return {
     Accept: "application/json",
     "Content-Type": "application/json",
-    "User-Agent": exports_app.useragent(app)
+    "User-Agent": useragent2(app)
   };
 }
 function request(url, init) {
@@ -310,7 +311,7 @@ function request(url, init) {
     catch: (cause) => cause
   });
 }
-function copilotFetch(token, upstream, app) {
+function copilotFetch2(token, upstream, app) {
   const send = upstream ?? fetch;
   return async (input, init) => {
     const requestHeaders = new Headers(init?.headers);
@@ -320,25 +321,25 @@ function copilotFetch(token, upstream, app) {
     return send(input, { ...init, headers: requestHeaders });
   };
 }
-function applyHeaders(headers2, token, app, metadata, anthropic) {
+function applyHeaders(headers, token, app, metadata, anthropic) {
   if (token) {
-    headers2.delete("authorization");
-    headers2.delete("x-api-key");
-    headers2.set("Authorization", `Bearer ${token}`);
+    headers.delete("authorization");
+    headers.delete("x-api-key");
+    headers.set("Authorization", `Bearer ${token}`);
   }
-  headers2.set("User-Agent", exports_app.useragent(app));
-  headers2.set("Openai-Intent", "conversation-edits");
-  headers2.set("X-GitHub-Api-Version", apiVersion);
+  headers.set("User-Agent", useragent2(app));
+  headers.set("Openai-Intent", "conversation-edits");
+  headers.set("X-GitHub-Api-Version", apiVersion);
   if (metadata.agent)
-    headers2.set("x-initiator", "agent");
-  else if (!headers2.has("x-initiator"))
-    headers2.set("x-initiator", "user");
+    headers.set("x-initiator", "agent");
+  else if (!headers.has("x-initiator"))
+    headers.set("x-initiator", "user");
   if (metadata.vision)
-    headers2.set("Copilot-Vision-Request", "true");
+    headers.set("Copilot-Vision-Request", "true");
   if (anthropic)
-    headers2.set("anthropic-beta", "interleaved-thinking-2025-05-14");
+    headers.set("anthropic-beta", "interleaved-thinking-2025-05-14");
 }
-function interactionType(kind, child) {
+function interactionType2(kind, child) {
   if (kind === "title")
     return "conversation-background";
   if (kind === "compaction")
@@ -351,9 +352,9 @@ function requestMetadata(url, body) {
   if (!record(body))
     return { agent: false, vision: false };
   if (Array.isArray(body.input)) {
-    const last2 = body.input.at(-1);
+    const last = body.input.at(-1);
     return {
-      agent: !record(last2) || last2.role !== "user",
+      agent: !record(last) || last.role !== "user",
       vision: body.input.some((item) => record(item) && Array.isArray(item.content) && item.content.some((part) => record(part) && part.type === "input_image"))
     };
   }
@@ -376,4 +377,4 @@ function record(input) {
   return typeof input === "object" && input !== null && !Array.isArray(input);
 }
 
-export { GithubCopilotPlugin, copilotEntitlementError, copilotBaseURL, copilotFetch, interactionType };
+export { GithubCopilotPlugin2, copilotEntitlementError2, copilotBaseURL2, copilotFetch2, interactionType2 };

package/dist/chunks/{schema-hzeg9cfr.js → pty-2axfhc9x.js}

@@ -1,31 +1,31 @@
 // src/util/error.ts
 import { Schema } from "effect";
 
-class NamedError extends Error {
+class NamedError2 extends Error {
   static hasName(error, name) {
     return typeof error === "object" && error !== null && "name" in error && error.name === name;
   }
   static create(name, data) {
-    return NamedError.createSchemaClass(name, Schema.isSchema(data) ? data : Schema.Struct(data));
+    return NamedError2.createSchemaClass(name, Schema.isSchema(data) ? data : Schema.Struct(data));
   }
   static createSchemaClass(name, data) {
     const schema = Schema.Struct({
       name: Schema.Literal(name),
       data
     }).annotate({ identifier: name });
-    const result = class extends NamedError {
+    const result = class extends NamedError2 {
       data;
       static Schema = schema;
       static EffectSchema = schema;
       static tag = name;
       name = name;
-      constructor(data2, options) {
+      constructor(data, options) {
         super(name, options);
-        this.data = data2;
+        this.data = data;
         this.name = name;
       }
       static isInstance(input) {
-        return NamedError.hasName(input, name);
+        return NamedError2.hasName(input, name);
       }
       schema() {
         return schema;
@@ -40,10 +40,10 @@ class NamedError extends Error {
     Object.defineProperty(result, "name", { value: name });
     return result;
   }
-  static Unknown = NamedError.create("UnknownError", {
+  static Unknown = NamedError2.create("UnknownError", {
     message: Schema.String,
     ref: Schema.optional(Schema.String)
   });
 }
 
-export { NamedError };
+export { NamedError2 };

package/dist/chunks/{schema-k7hkdbw5.js → pty-2ht70gj7.js}

@@ -1,12 +1,9 @@
 import {
-  createProviderPlugin
-} from "./schema-0zz82cjq.js";
-import {
-  __require
-} from "./schema-vpjkya7h.js";
+  createProviderPlugin2
+} from "./pty-se0s1eqw.js";
 
 // src/plugin/provider/venice.ts
-var VenicePlugin = createProviderPlugin({
+var VenicePlugin2 = createProviderPlugin2({
   id: "opencode.provider.venice",
   package: "venice-ai-sdk-provider",
   load: async (options) => {
@@ -15,4 +12,4 @@ var VenicePlugin = createProviderPlugin({
   }
 });
 
-export { VenicePlugin };
+export { VenicePlugin2 };

package/dist/chunks/{schema-r7a2r1m6.js → pty-2jqmte8w.js}

@@ -1,16 +1,16 @@
 import {
-  exports_promise
-} from "./schema-hy5n5jcn.js";
+  fromPromise2
+} from "./pty-b9wsbatv.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./pty-9rqn6x4v.js";
 
 // src/plugin/module.ts
 var exports_module = {};
 __export(exports_module, {
-  LoadError: () => LoadError,
+  LoadError: () => LoadError2,
   PluginModule: () => exports_module,
-  load: () => load
+  load: () => load2
 });
 import { Host } from "@opencode-ai/plugin/host";
 import { Npm } from "@opencode-ai/util/npm";
@@ -31,12 +31,12 @@ var Module = Schema.Struct({
   ])
 });
 
-class LoadError extends Schema.TaggedError()("PluginModule.LoadError", {
+class LoadError2 extends Schema.TaggedError()("PluginModule.LoadError", {
   message: Schema.String,
   cause: Schema.optional(Schema.Defect())
 }) {
 }
-var load = Effect.fn("PluginModule.load")(function* (operation, options) {
+var load2 = Effect.fn("PluginModule.load")(function* (operation, options) {
   const local = path.isAbsolute(operation.target);
   const npm = yield* Npm.Service;
   const installed = local ? undefined : options?.install === false ? yield* npm.resolve(operation.target) : yield* npm.add(operation.target);
@@ -45,16 +45,16 @@ var load = Effect.fn("PluginModule.load")(function* (operation, options) {
   if (!local && options?.install === false && !entrypoint)
     return { pending: true };
   if (!entrypoint)
-    return yield* new LoadError({ message: `Plugin entrypoint not found: ${operation.target}` });
+    return yield* new LoadError2({ message: `Plugin entrypoint not found: ${operation.target}` });
   const target = typeof Bun !== "undefined" ? fileURLToPath(entrypoint).replaceAll("\\", "/") : entrypoint;
   const source = operation.mtime === undefined ? entrypoint : `${target}?mtime=${operation.mtime}`;
   yield* Effect.log({ msg: "loading plugin", id: operation.target, entrypoint: source });
   const mod = yield* Effect.promise(() => Host.load(source));
-  const value = (yield* Schema.decodeUnknownEffect(Module)(mod).pipe(Effect.mapError((cause) => new LoadError({
+  const value = (yield* Schema.decodeUnknownEffect(Module)(mod).pipe(Effect.mapError((cause) => new LoadError2({
     message: "Plugin must export a default definition with an id and an effect or setup function.",
     cause
   })))).default;
-  const plugin = "effect" in value ? value : exports_promise.fromPromise(value);
+  const plugin = "effect" in value ? value : fromPromise2(value);
   return {
     id: plugin.id,
     features: {
@@ -71,4 +71,4 @@ var load = Effect.fn("PluginModule.load")(function* (operation, options) {
   };
 });
 
-export { LoadError, load, exports_module };
+export { LoadError2, load2, exports_module };

package/dist/chunks/pty-2vw6f4gm.js

@@ -0,0 +1,33 @@
+import {
+  Service35
+} from "./pty-k558dr3h.js";
+import {
+  awaitActivation2
+} from "./pty-1x11rq2a.js";
+import {
+  SkillNotFoundError2
+} from "./pty-3wx44s71.js";
+import {
+  Service52
+} from "./pty-5b9mh310.js";
+import {
+  __export
+} from "./pty-9rqn6x4v.js";
+
+// src/session/skill.ts
+var exports_skill4 = {};
+__export(exports_skill4, {
+  SessionSkill: () => exports_skill4,
+  get: () => get4
+});
+import { Effect } from "effect";
+var get4 = Effect.fn("SessionSkill.get")(function* (input) {
+  const instances = yield* Service35;
+  const skills = yield* awaitActivation2.pipe(Effect.andThen(Service52), instances.provide(input.session));
+  const skill = yield* skills.get(input.skill);
+  if (!skill)
+    return yield* new SkillNotFoundError2({ skill: input.skill });
+  return skill;
+});
+
+export { get4, exports_skill4 };

package/dist/chunks/{schema-eb87q0yv.js → pty-2wkcjqsg.js}

@@ -1,18 +1,19 @@
 import {
-  exports_provider
-} from "./schema-68yag814.js";
+  isAISDK2,
+  packageName2
+} from "./pty-tdt6s1r3.js";
 
 // src/plugin/provider/nvidia.ts
 import { Effect } from "effect";
 import { define } from "@opencode-ai/plugin/effect/plugin";
-var NvidiaPlugin = define({
+var NvidiaPlugin2 = define({
   id: "opencode.provider.nvidia",
   effect: Effect.fn(function* (ctx) {
     yield* ctx.catalog.transform((evt) => {
       for (const item of evt.provider.list()) {
-        if (!exports_provider.isAISDK(item.provider.package))
+        if (!isAISDK2(item.provider.package))
           continue;
-        if (exports_provider.packageName(item.provider.package) !== "@ai-sdk/openai-compatible")
+        if (packageName2(item.provider.package) !== "@ai-sdk/openai-compatible")
           continue;
         if (item.provider.settings?.baseURL !== "https://integrate.api.nvidia.com/v1")
           continue;
@@ -29,4 +30,4 @@ var NvidiaPlugin = define({
   })
 });
 
-export { NvidiaPlugin };
+export { NvidiaPlugin2 };

package/dist/chunks/{schema-m8cbvarh.js → pty-3asan66x.js}

@@ -1,5 +1,5 @@
 // src/github-copilot/responses/map-openai-responses-finish-reason.ts
-function mapOpenAIResponseFinishReason({
+function mapOpenAIResponseFinishReason2({
   finishReason,
   hasFunctionCall
 }) {
@@ -16,4 +16,4 @@ function mapOpenAIResponseFinishReason({
   }
 }
 
-export { mapOpenAIResponseFinishReason };
+export { mapOpenAIResponseFinishReason2 };

package/dist/chunks/{schema-rr7wbarq.js → pty-3fc6dm20.js}

@@ -1,18 +1,18 @@
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./pty-9rqn6x4v.js";
 
 // src/codemode/catalog.ts
 var exports_catalog = {};
 __export(exports_catalog, {
   CodeModeCatalog: () => exports_catalog,
-  Summary: () => Summary,
-  Tool: () => Tool,
-  namespaceLine: () => namespaceLine,
-  summarize: () => summarize
+  Summary: () => Summary2,
+  Tool: () => Tool2,
+  namespaceLine: () => namespaceLine2,
+  summarize: () => summarize2
 });
 import { Schema } from "effect";
-var Tool = Schema.Struct({
+var Tool2 = Schema.Struct({
   type: Schema.Literal("tool"),
   name: Schema.String,
   description: Schema.String,
@@ -29,7 +29,7 @@ var NamespaceSummary = Schema.Struct({
   count: Schema.Number,
   entries: Schema.Array(Listing)
 });
-var Summary = Schema.Struct({
+var Summary2 = Schema.Struct({
   total: Schema.Number,
   shown: Schema.Number,
   namespaces: Schema.Array(NamespaceSummary)
@@ -37,7 +37,7 @@ var Summary = Schema.Struct({
 var DESCRIPTION_LIMIT = 120;
 var CHARACTERS_PER_TOKEN = 4;
 var INLINE_BUDGET = 2000;
-function summarize(inventory, options = {}) {
+function summarize2(inventory, options = {}) {
   const budget = options.budget ?? INLINE_BUDGET;
   const flattened = flatten(inventory.tools);
   const namespaces = [...Map.groupBy(flattened.tools, (tool) => tool.path.split(".", 1)[0] ?? tool.path)].sort(([left], [right]) => {
@@ -51,8 +51,8 @@ function summarize(inventory, options = {}) {
     const listings = namespaceEntries.map((entry) => {
       const firstLine = entry.description.split(`
 `, 1)[0]?.trim() ?? "";
-      const description2 = firstLine.length > DESCRIPTION_LIMIT ? firstLine.slice(0, DESCRIPTION_LIMIT - 3) + "..." : firstLine;
-      const suffix = description2.length === 0 ? "" : ` // ${description2}`;
+      const description = firstLine.length > DESCRIPTION_LIMIT ? firstLine.slice(0, DESCRIPTION_LIMIT - 3) + "..." : firstLine;
+      const suffix = description.length === 0 ? "" : ` // ${description}`;
       return { path: entry.path, line: `  - ${entry.signature}${suffix}` };
     }).toSorted((left, right) => {
       if (left.path < right.path)
@@ -73,7 +73,7 @@ function summarize(inventory, options = {}) {
     };
   });
   const active = new Set(namespaces);
-  let remaining = budget - namespaces.reduce((total, namespace) => total + cost(namespaceLine({
+  let remaining = budget - namespaces.reduce((total, namespace) => total + cost(namespaceLine2({
     name: namespace.name,
     ...namespace.description === undefined ? {} : { description: namespace.description },
     count: namespace.listings.length,
@@ -128,7 +128,7 @@ function flatten(entries, path = []) {
   }
   return { tools, namespaces };
 }
-function namespaceLine(namespace) {
+function namespaceLine2(namespace) {
   const count = namespace.count === 1 ? "1 tool" : `${namespace.count} tools`;
   const label = namespace.entries.length === namespace.count ? count : namespace.entries.length === 0 ? `${count}, none shown` : `${count}, ${namespace.entries.length} shown`;
   return `- ${namespace.name} (${label})${namespace.description === undefined ? "" : ` // ${namespace.description}`}`;
@@ -148,4 +148,4 @@ function cost(text) {
   return Math.round(text.length / CHARACTERS_PER_TOKEN);
 }
 
-export { Tool, Summary, summarize, namespaceLine, exports_catalog };
+export { Tool2, Summary2, summarize2, namespaceLine2, exports_catalog };

package/dist/chunks/{schema-wmxdh12w.js → pty-3hepkmqq.js}

@@ -1,13 +1,13 @@
 import {
-  Timestamps
-} from "./schema-sem2g21k.js";
+  Timestamps2
+} from "./pty-qfa1cgps.js";
 
 // src/kv/sql.ts
 import { sqliteTable, text } from "drizzle-orm/sqlite-core";
-var KVTable = sqliteTable("kv", {
+var KVTable2 = sqliteTable("kv", {
   key: text().primaryKey(),
   value: text({ mode: "json" }).$type().notNull(),
-  ...Timestamps
+  ...Timestamps2
 });
 
-export { KVTable };
+export { KVTable2 };