@opencode/core 0.0.0-dev-20300 → 0.0.0-dev-20303

package/dist/chunks/ripgrep-31wx1wqg.js

@@ -0,0 +1,424 @@
+import {
+  useragent2
+} from "./ripgrep-mtf32xg9.js";
+import {
+  Service80
+} from "./ripgrep-kcetpk2c.js";
+import {
+  ID14,
+  OAuth3,
+  Event17,
+  Service68
+} from "./ripgrep-gmfetzq4.js";
+import {
+  key2
+} from "./ripgrep-3y377wv9.js";
+import {
+  ID13,
+  MethodID2
+} from "./ripgrep-bahgfxtd.js";
+import {
+  ID12,
+  mergeOverlay2
+} from "./ripgrep-zexvq6re.js";
+import {
+  ID11,
+  VariantID2,
+  Info24
+} from "./ripgrep-ag1tg3gv.js";
+import {
+  success2,
+  error2
+} from "./ripgrep-pjvnvgmy.js";
+
+// src/plugin/provider/chatgpt.ts
+import { define } from "@opencode/plugin/effect/plugin";
+import { Deferred, Duration, Effect, Option, Schema, Semaphore, Stream } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+var registrationClientID = "dynamic_agent_client";
+var agentName = "OpenCode";
+var issuer = "https://auth.openai.com";
+var tokenURL = `${issuer}/api/accounts/oauth/token`;
+var resource = "https://api.openai.com/v1";
+var tokenSharingScope = "chatgpt.tokens.use.direct";
+var providerID = ID12.openai;
+var integrationID = ID13.make("openai");
+var methodID = MethodID2.make("chatgpt-token-sharing");
+var modelCacheKey = (clientID) => `models:${clientID}`;
+var fallbackModels = new Set([
+  "gpt-5.5",
+  "gpt-5.5-fast",
+  "gpt-5.6-luna",
+  "gpt-5.6-luna-fast",
+  "gpt-5.6-sol",
+  "gpt-5.6-sol-fast",
+  "gpt-5.6-terra",
+  "gpt-5.6-terra-fast",
+  "gpt-6-astra",
+  "gpt-6-astra-fast"
+]);
+var nonRetryableSharingCodes = [
+  "subscription_sharing_usage_limit_exceeded",
+  "subscription_sharing_v2_user_not_eligible",
+  "subscription_sharing_unsupported_capability",
+  "subscription_sharing_v2_client_not_enabled",
+  "subscription_sharing_v2_route_not_supported",
+  "subscription_sharing_v2_invalid_user"
+];
+var RemoteModel = Schema.Struct({
+  slug: Schema.String,
+  display_name: Schema.String,
+  visibility: Schema.String,
+  supported_in_api: Schema.Boolean,
+  context_window: Schema.Int.check(Schema.isGreaterThan(1)),
+  input_modalities: Schema.Array(Schema.String),
+  supported_reasoning_levels: Schema.optional(Schema.Array(Schema.Struct({ effort: Schema.String })))
+});
+var RemoteModels = Schema.Struct({ models: Schema.Array(RemoteModel) });
+var decodeCachedModels = Schema.decodeUnknownOption(Schema.Array(RemoteModel));
+var decodeMetadata = Schema.decodeUnknownOption(Schema.Struct({
+  clientID: Schema.String,
+  scopes: Schema.optional(Schema.Array(Schema.String)),
+  models: Schema.optional(Schema.Array(RemoteModel))
+}));
+var signIn = (app, savedClientID, storage) => ({
+  integrationID,
+  method: {
+    id: methodID,
+    type: "oauth",
+    label: "Sign in with ChatGPT"
+  },
+  authorize: () => Effect.gen(function* () {
+    const storedHostID = yield* storage.get("chatgpt-agent-host-id");
+    const hostID = typeof storedHostID === "string" ? storedHostID : `urn:uuid:${crypto.randomUUID()}`;
+    if (typeof storedHostID !== "string")
+      yield* storage.set("chatgpt-agent-host-id", hostID);
+    const pkce = yield* Effect.promise(generatePKCE);
+    const state = randomValue();
+    const nonce = randomValue();
+    const savedID = savedClientID();
+    const received = yield* Deferred.make();
+    const { createServer } = yield* Effect.promise(() => import("node:http"));
+    const server = createServer((request, response) => {
+      const url = new URL(request.url ?? "/", "http://127.0.0.1");
+      if (url.pathname !== "/auth/callback") {
+        response.writeHead(404).end("Not found");
+        return;
+      }
+      const error = url.searchParams.get("error_description") ?? url.searchParams.get("error");
+      const authorizationCode = url.searchParams.get("code");
+      if (error) {
+        Effect.runFork(Deferred.fail(received, new Error(error)));
+        response.writeHead(400, { "Content-Type": "text/html" }).end(error2(error, { provider: "ChatGPT" }));
+        return;
+      }
+      if (!authorizationCode || url.searchParams.get("state") !== state) {
+        const message = authorizationCode ? "Invalid OAuth state" : "Missing authorization code";
+        Effect.runFork(Deferred.fail(received, new Error(message)));
+        response.writeHead(400, { "Content-Type": "text/html" }).end(error2(message, { provider: "ChatGPT" }));
+        return;
+      }
+      if (!Effect.runSync(Deferred.succeed(received, {
+        code: authorizationCode,
+        clientID: url.searchParams.get("client_id") ?? undefined,
+        response
+      })))
+        response.writeHead(409).end("OAuth callback already received");
+    });
+    const port = yield* listen(server);
+    yield* Effect.addFinalizer(() => Effect.sync(() => server.close()));
+    const redirect = `http://127.0.0.1:${port}/auth/callback`;
+    return {
+      mode: "auto",
+      url: authorizeURL(redirect, pkce, state, nonce, savedID, hostID),
+      instructions: "Complete authorization in your browser. This window will close automatically.",
+      callback: Effect.gen(function* () {
+        const result = yield* Deferred.await(received);
+        const respond = (error) => Effect.sync(() => result.response.writeHead(error ? 400 : 200, { "Content-Type": "text/html" }).end(error ? error2(error, { provider: "ChatGPT" }) : success2({ provider: "ChatGPT" })));
+        return yield* Effect.gen(function* () {
+          const clientID = result.clientID ?? savedID;
+          if (!clientID)
+            return yield* Effect.fail(new Error("ChatGPT sign-in did not return a client ID. Connect again."));
+          const tokens = yield* exchange(result.code, clientID, redirect, pkce, app);
+          if (!tokens.scope?.split(" ").includes(tokenSharingScope))
+            return yield* Effect.fail(new Error("ChatGPT sign-in finished without token sharing. Sign in again and allow token sharing, or connect OpenAI with an API key."));
+          if (!tokens.id_token)
+            return yield* Effect.fail(new Error("ChatGPT sign-in did not return an ID token."));
+          yield* verifyIDToken2(tokens.id_token, clientID, nonce);
+          return credential(tokens, clientID);
+        }).pipe(Effect.tap(() => respond()), Effect.tapError((error) => respond(error instanceof Error ? error.message : "ChatGPT sign-in failed")), Effect.onInterrupt(() => Effect.sync(() => result.response.destroy())));
+      })
+    };
+  }),
+  refresh: (value) => refresh(value, app)
+});
+function listen(server) {
+  return Effect.callback((resume) => {
+    const onError = (error) => resume(Effect.fail(error));
+    server.once("error", onError);
+    server.listen(0, "127.0.0.1", () => {
+      server.off("error", onError);
+      const address = server.address();
+      if (!address || typeof address === "string")
+        return resume(Effect.fail(new Error("Missing OAuth callback port")));
+      resume(Effect.succeed(address.port));
+    });
+  });
+}
+var ChatGPTPlugin2 = define({
+  id: "opencode.provider.chatgpt",
+  effect: Effect.fn(function* (ctx) {
+    const bus = yield* Service80;
+    const credentials = yield* Service68;
+    const loading = Semaphore.makeUnsafe(1);
+    let chatgpt;
+    let available;
+    let source;
+    const load = Effect.fn("ChatGPTPlugin.load")(function* () {
+      const previous = key2(source);
+      const connection = yield* ctx.integration.connection.active(integrationID);
+      const credential = connection ? yield* ctx.integration.connection.resolve(connection).pipe(Effect.orElseSucceed(() => {
+        return;
+      })) : undefined;
+      chatgpt = credential?.type === "oauth" && credential.methodID === methodID ? credential : undefined;
+      source = chatgpt ? connection : undefined;
+      if (previous !== key2(source)) {
+        const metadata = Option.getOrUndefined(decodeMetadata(chatgpt?.metadata));
+        const stored = metadata ? yield* ctx.storage.get(modelCacheKey(metadata.clientID)) : undefined;
+        available = Option.getOrUndefined(decodeCachedModels(stored));
+      }
+    });
+    yield* ctx.integration.transform((editor) => {
+      editor.method.update(signIn(ctx.app, () => Option.getOrUndefined(decodeMetadata(chatgpt?.metadata))?.clientID, ctx.storage));
+    });
+    yield* Effect.forEach(yield* credentials.list(ID13.make("openai")), (entry) => {
+      const value = entry.value;
+      if (value.type !== "oauth" || value.methodID !== MethodID2.make("chatgpt-browser"))
+        return Effect.void;
+      const metadata = Option.getOrUndefined(decodeMetadata(value.metadata));
+      if (!metadata)
+        return Effect.void;
+      return Effect.gen(function* () {
+        const saved = yield* ctx.storage.get(modelCacheKey(metadata.clientID));
+        if (!Option.isSome(decodeCachedModels(saved)) && metadata.models)
+          yield* ctx.storage.set(modelCacheKey(metadata.clientID), metadata.models);
+        const { models: _, ...rest } = value.metadata ?? {};
+        yield* credentials.update(entry.id, {
+          value: OAuth3.make({ ...value, methodID, metadata: rest })
+        });
+      });
+    }, { discard: true });
+    yield* load();
+    yield* ctx.session.hook("retry", (event) => Effect.sync(() => {
+      if (!chatgpt || !nonRetryableSharingCodes.some((code) => event.error.response?.body.includes(code)))
+        return;
+      event.decision = { retry: false };
+    }), { providerID });
+    yield* ctx.provider.transform((providers) => {
+      const item = providers.get(providerID);
+      if (!item)
+        return;
+      if (!chatgpt || !source)
+        return;
+      providers.update(providerID, (provider) => {
+        provider.settings = mergeOverlay2(provider.settings, {
+          baseURL: resource,
+          transport: "http",
+          compaction: { type: "summary" }
+        });
+      });
+      const updated = providers.get(providerID);
+      if (!updated)
+        return;
+      providers.add({
+        info: updated.provider,
+        models: available ? deriveModels2(available, Array.from(item.models.values())) : Array.from(item.models.values()).filter((model) => fallbackModels.has(model.id)),
+        sourceConnection: source
+      });
+    });
+    yield* ctx.model.transform((models) => {
+      for (const model of models.list(providerID)) {
+        models.update(model.providerID, model.id, (draft) => {
+          if (!chatgpt)
+            return;
+          draft.settings = { ...draft.settings, compaction: { type: "summary" } };
+          if (Schema.is(Schema.Struct({ mode: Schema.Literal("pro") }))(draft.body?.reasoning)) {
+            draft.enabled = false;
+            return;
+          }
+          if (available && !available.some((remote) => remote.slug === (draft.modelID ?? draft.id))) {
+            draft.enabled = false;
+            return;
+          }
+          draft.cost = [];
+        });
+      }
+    });
+    const refreshModels = Effect.fn("ChatGPTPlugin.refreshModels")(function* () {
+      const connection = source;
+      const credential = connection?.type === "credential" ? (yield* credentials.get(ID14.make(connection.id)))?.value : undefined;
+      if (credential?.type !== "oauth" || credential.methodID !== methodID || credential.expires <= Date.now() + 60000)
+        return;
+      const metadata = Option.getOrUndefined(decodeMetadata(credential.metadata));
+      if (!metadata)
+        return;
+      const models = yield* fetchModels2(credential.access, ctx.app).pipe(Effect.timeout(15000), Effect.catch(() => Effect.logWarning("failed to refresh ChatGPT models").pipe(Effect.as(undefined))));
+      if (!models)
+        return;
+      yield* loading.withPermit(Effect.gen(function* () {
+        if (key2(connection) !== key2(source) || key2(connection) !== key2(yield* ctx.integration.connection.active(integrationID)))
+          return;
+        if (JSON.stringify(models) === JSON.stringify(available))
+          return;
+        yield* ctx.storage.set(modelCacheKey(metadata.clientID), models);
+        available = models;
+        yield* ctx.provider.reload();
+      }));
+    });
+    const reload = () => loading.withPermit(load().pipe(Effect.andThen(ctx.provider.reload()))).pipe(Effect.andThen(refreshModels().pipe(Effect.forkScoped, Effect.asVoid)));
+    yield* bus.subscribe(Event17.Switched).pipe(Stream.filter((event) => event.data.integrationID === integrationID), Stream.runForEach(reload), Effect.forkScoped({ startImmediately: true }));
+    yield* refreshModels().pipe(Effect.forkScoped);
+    yield* Effect.sleep(Duration.minutes(15)).pipe(Effect.andThen(refreshModels), Effect.forever, Effect.forkScoped);
+  })
+});
+function headers(app) {
+  return { "Content-Type": "application/x-www-form-urlencoded", "User-Agent": useragent2(app) };
+}
+function exchange(code, clientID, redirect, pkce, app) {
+  return request(tokenURL, {
+    method: "POST",
+    headers: headers(app),
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      client_id: clientID,
+      code,
+      code_verifier: pkce.verifier,
+      redirect_uri: redirect,
+      resource
+    }).toString()
+  });
+}
+function refresh(value, app) {
+  return Effect.gen(function* () {
+    const metadata = Option.getOrUndefined(decodeMetadata(value.metadata));
+    if (!metadata)
+      return yield* Effect.fail(new Error("This ChatGPT connection has no registered client ID. Connect again."));
+    const tokens = yield* request(tokenURL, {
+      method: "POST",
+      headers: headers(app),
+      body: new URLSearchParams({
+        grant_type: "refresh_token",
+        client_id: metadata.clientID,
+        refresh_token: value.refresh,
+        resource
+      }).toString()
+    });
+    return credential(tokens, metadata.clientID, metadata.scopes);
+  });
+}
+function fetchModels2(token, app, baseURL = resource) {
+  return Effect.gen(function* () {
+    const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient);
+    const response = yield* http.execute(HttpClientRequest.get(`${baseURL}/models`).pipe(HttpClientRequest.bearerToken(token), HttpClientRequest.setHeader("User-Agent", useragent2(app))));
+    const data = yield* HttpClientResponse.schemaBodyJson(RemoteModels)(response);
+    const models = data.models.filter((model) => model.visibility === "list" && model.supported_in_api);
+    if (!models.length)
+      return yield* Effect.fail(new Error("No ChatGPT models are available for this account."));
+    return models;
+  });
+}
+function deriveModels2(remote, existing) {
+  const byID = new Map(remote.map((model) => [model.slug, model]));
+  const known = new Set(existing.map((model) => model.id));
+  return [
+    ...existing.flatMap((model) => {
+      const found = byID.get(model.modelID);
+      return found ? [deriveModel(found, model)] : [];
+    }),
+    ...remote.filter((model) => !known.has(ID11.make(model.slug))).map((model) => deriveModel(model, Info24.default(ID12.openai, ID11.make(model.slug))))
+  ];
+}
+function deriveModel(remote, previous) {
+  return {
+    ...previous,
+    name: previous.id === previous.modelID ? remote.display_name : previous.name,
+    package: previous.package ?? "@opencode/ai/providers/openai",
+    capabilities: {
+      ...previous.capabilities,
+      input: remote.input_modalities.filter((modality) => modality === "text" || modality === "image")
+    },
+    variants: [
+      ...previous.variants.filter((variant) => typeof variant.settings?.reasoningEffort !== "string"),
+      ...(remote.supported_reasoning_levels ?? []).map(({ effort }) => previous.variants.find((variant) => variant.id === effort && variant.settings?.reasoningEffort === effort) ?? { id: VariantID2.make(effort), settings: { reasoningEffort: effort } })
+    ],
+    limit: { context: remote.context_window, output: previous.limit.output }
+  };
+}
+function verifyIDToken2(token, clientID, nonce, jwksURL = new URL(`${issuer}/.well-known/jwks.json`)) {
+  return Effect.tryPromise({
+    try: async () => {
+      const { createRemoteJWKSet, jwtVerify } = await import("jose");
+      const { payload } = await jwtVerify(token, createRemoteJWKSet(jwksURL), {
+        issuer,
+        audience: clientID,
+        algorithms: ["RS256"],
+        requiredClaims: ["exp", "nonce", "sub"]
+      });
+      if (typeof payload.sub !== "string" || !payload.sub.trim())
+        throw new Error("ID token subject is missing");
+      if (payload.nonce !== nonce)
+        throw new Error("ID token nonce does not match this sign-in attempt");
+    },
+    catch: (cause) => new Error("ChatGPT sign-in returned an invalid ID token.", { cause })
+  });
+}
+function request(url, init) {
+  return Effect.tryPromise({
+    try: async (signal) => {
+      const response = await fetch(url, { ...init, signal });
+      if (!response.ok)
+        throw new Error(`Request failed: ${response.status}`);
+      return response.json();
+    },
+    catch: (cause) => cause
+  });
+}
+function credential(tokens, clientID, scopes) {
+  return OAuth3.make({
+    type: "oauth",
+    methodID,
+    refresh: tokens.refresh_token,
+    access: tokens.access_token,
+    expires: Date.now() + (tokens.expires_in ?? 3600) * 1000,
+    metadata: { clientID, scopes: tokens.scope?.split(" ").filter(Boolean) ?? scopes ?? [] }
+  });
+}
+async function generatePKCE() {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~";
+  const verifier = Array.from(crypto.getRandomValues(new Uint8Array(43)), (byte) => chars[byte % chars.length]).join("");
+  const challenge = base64UrlEncode(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier)));
+  return { verifier, challenge };
+}
+function randomValue() {
+  return base64UrlEncode(crypto.getRandomValues(new Uint8Array(32)).buffer);
+}
+function base64UrlEncode(buffer) {
+  return Buffer.from(buffer).toString("base64url");
+}
+function authorizeURL(redirect, pkce, state, nonce, savedID, hostID) {
+  return `${issuer}/api/accounts/authorize?${new URLSearchParams({
+    client_id: savedID ?? registrationClientID,
+    ...savedID ? {} : { agent_name_hint: agentName },
+    ext_agent_host_id: hostID,
+    response_type: "code",
+    redirect_uri: redirect,
+    scope: `openid profile email offline_access resource.invoke ${tokenSharingScope}`,
+    resource,
+    state,
+    nonce,
+    code_challenge_method: "S256",
+    code_challenge: pkce.challenge
+  })}`;
+}
+
+export { ChatGPTPlugin2, fetchModels2, deriveModels2, verifyIDToken2 };

package/dist/chunks/{event-logger-e6hd9jay.js → ripgrep-35agz59w.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./event-logger-9rqn6x4v.js";
+} from "./ripgrep-9rqn6x4v.js";
 
 // src/v1/config/lsp.ts
 var exports_lsp = {};
@@ -8,7 +8,7 @@ __export(exports_lsp, {
   ConfigLSPV1: () => exports_lsp,
   Disabled: () => Disabled2,
   Entry: () => Entry3,
-  Info: () => Info11,
+  Info: () => Info18,
   builtinServerIds: () => builtinServerIds2,
   requiresExtensionsForCustomServers: () => requiresExtensionsForCustomServers2
 });
@@ -79,6 +79,6 @@ var requiresExtensionsForCustomServers2 = Schema.makeFilter((data) => {
   });
   return ok ? undefined : "For custom LSP servers, 'extensions' array is required.";
 });
-var Info11 = Schema.Union([Schema.Boolean, Schema.Record(Schema.String, Entry3)]).check(requiresExtensionsForCustomServers2);
+var Info18 = Schema.Union([Schema.Boolean, Schema.Record(Schema.String, Entry3)]).check(requiresExtensionsForCustomServers2);
 
-export { Disabled2, Entry3, builtinServerIds2, requiresExtensionsForCustomServers2, Info11, exports_lsp };
+export { Disabled2, Entry3, builtinServerIds2, requiresExtensionsForCustomServers2, Info18, exports_lsp };

package/dist/chunks/{event-logger-arjnx064.js → ripgrep-37m9xwpn.js}

@@ -1,32 +1,32 @@
 import {
-  Service83,
-  node87
-} from "./event-logger-nez6t23e.js";
+  Service80,
+  node84
+} from "./ripgrep-kcetpk2c.js";
 import {
   create3
-} from "./event-logger-rdw6cm16.js";
+} from "./ripgrep-rdw6cm16.js";
 import {
   evaluate2
-} from "./event-logger-aaa6x6ax.js";
+} from "./ripgrep-n50qm4s2.js";
 import {
   __export
-} from "./event-logger-9rqn6x4v.js";
+} from "./ripgrep-9rqn6x4v.js";
 
 // src/skill.ts
 var exports_skill5 = {};
 __export(exports_skill5, {
   DirectorySource: () => DirectorySource2,
   EmbeddedSource: () => EmbeddedSource2,
-  Event: () => Event12,
-  ID: () => ID6,
-  Info: () => Info18,
+  Event: () => Event7,
+  ID: () => ID5,
+  Info: () => Info7,
   Name: () => Name2,
-  Service: () => Service58,
+  Service: () => Service40,
   Skill: () => exports_skill5,
-  Source: () => Source3,
+  Source: () => Source4,
   UrlSource: () => UrlSource2,
   available: () => available2,
-  node: () => node60,
+  node: () => node43,
   prepare: () => prepare3,
   toModelOutput: () => toModelOutput3
 });
@@ -34,13 +34,13 @@ import { makeLocationNode } from "@opencode/util/effect/app-node";
 import path from "path";
 import { Context, Effect, Layer } from "effect";
 import { Skill } from "@opencode/schema/skill";
-import { Event as Event12 } from "@opencode/schema/skill";
+import { Event as Event7 } from "@opencode/schema/skill";
 var DirectorySource2 = Skill.DirectorySource;
 var UrlSource2 = Skill.UrlSource;
 var EmbeddedSource2 = Skill.EmbeddedSource;
-var Source3 = Skill.Source;
-var Info18 = Skill.Info;
-var ID6 = Skill.ID;
+var Source4 = Skill.Source;
+var Info7 = Skill.Info;
+var ID5 = Skill.ID;
 var Name2 = Skill.Name;
 var available2 = (skills, permissions) => skills.filter((skill) => evaluate2("skill", skill.id, permissions).effect !== "deny");
 var toModelOutput3 = (skill, files) => {
@@ -71,33 +71,33 @@ var prepare3 = Effect.fn("Skill.prepare")(function* (fs, skill) {
   };
 });
 
-class Service58 extends Context.Service()("@opencode/Skill") {
+class Service40 extends Context.Service()("@opencode/Skill") {
 }
-var layer = Layer.effect(Service58, Effect.gen(function* () {
-  const bus = yield* Service83;
+var layer = Layer.effect(Service40, Effect.gen(function* () {
+  const bus = yield* Service80;
   const state = create3({
     name: "skill",
     initial: () => ({ skills: new Map }),
     editor: (editor) => ({
       list: () => Array.from(editor.skills.values()),
-      get: (id) => editor.skills.get(ID6.make(id)),
+      get: (id) => editor.skills.get(ID5.make(id)),
       add: (skill) => {
         editor.skills.set(skill.id, { ...skill });
       },
       update: (id, update) => {
-        const current = editor.skills.get(ID6.make(id));
+        const current = editor.skills.get(ID5.make(id));
         if (!current)
           return;
         update(current);
-        current.id = ID6.make(id);
+        current.id = ID5.make(id);
       },
       remove: (id) => {
-        editor.skills.delete(ID6.make(id));
+        editor.skills.delete(ID5.make(id));
       }
     }),
     notify: () => bus.publish(Skill.Event.Updated, {}).pipe(Effect.asVoid)
   });
-  return Service58.of({
+  return Service40.of({
     transform: state.transform,
     reload: state.reload,
     get: Effect.fn("Skill.get")(function* (id) {
@@ -108,10 +108,10 @@ var layer = Layer.effect(Service58, Effect.gen(function* () {
     })
   });
 }));
-var node60 = makeLocationNode({
-  service: Service58,
+var node43 = makeLocationNode({
+  service: Service40,
   layer,
-  deps: [node87]
+  deps: [node84]
 });
 
-export { DirectorySource2, UrlSource2, EmbeddedSource2, Source3, Info18, ID6, Name2, available2, toModelOutput3, prepare3, Service58, node60, exports_skill5, Event12 };
+export { DirectorySource2, UrlSource2, EmbeddedSource2, Source4, Info7, ID5, Name2, available2, toModelOutput3, prepare3, Service40, node43, exports_skill5, Event7 };