@opencode-ai/core 0.0.0-dev-17471

package/dist/chunks/location-mutation-z17t3kn2.js

@@ -0,0 +1,75 @@
+import {
+  exports_location
+} from "./location-mutation-57ntp81p.js";
+import {
+  exports_project
+} from "./location-mutation-sbx2darh.js";
+import {
+  AbsolutePath
+} from "./location-mutation-j07kk359.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/location-mutation.ts
+var exports_location_mutation = {};
+__export(exports_location_mutation, {
+  node: () => node,
+  externalDirectoryPermission: () => externalDirectoryPermission,
+  Service: () => Service,
+  ResolveInput: () => ResolveInput,
+  LocationMutation: () => exports_location_mutation,
+  Kind: () => Kind
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import path from "path";
+import { Context, Effect, Layer, Schema } from "effect";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+var Kind = Schema.Literals(["file", "directory"]);
+var ResolveInput = Schema.Struct({
+  path: Schema.String,
+  kind: Kind.pipe(Schema.optional)
+});
+var externalDirectoryPermission = (input) => ({
+  action: input.action,
+  resources: [input.resource],
+  save: [input.save]
+});
+
+class Service extends Context.Service()("@opencode/LocationMutation") {
+}
+var slash = (value) => value.replaceAll("\\", "/");
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const location = yield* exports_location.Service;
+  const resolve = Effect.fn("LocationMutation.resolve")(function* (input) {
+    const absolute = path.resolve(location.directory, input.path);
+    if (FSUtil.contains(location.directory, absolute)) {
+      return {
+        absolute,
+        resource: slash(path.relative(location.directory, absolute) || ".")
+      };
+    }
+    const type = input.kind === "directory" ? "Directory" : input.kind === "file" ? "File" : (yield* fs.stat(absolute).pipe(Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(undefined))))?.type;
+    const externalDirectory = type === "Directory" ? absolute : path.dirname(absolute);
+    const externalResource = slash(path.join(externalDirectory, "*"));
+    return {
+      absolute,
+      resource: slash(absolute),
+      externalDirectory: {
+        action: "external_directory",
+        directory: externalDirectory,
+        resource: externalResource,
+        save: slash(path.join((yield* exports_project.root(fs, AbsolutePath.make(externalDirectory))) ?? externalDirectory, "*"))
+      }
+    };
+  });
+  return Service.of({ resolve });
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer: layer.pipe(Layer.orDie),
+  deps: [FSUtil.node, exports_location.node]
+});
+
+export { Kind, ResolveInput, externalDirectoryPermission, Service, node, exports_location_mutation };

package/dist/chunks/location-mutation-z47nswr2.js

@@ -0,0 +1,16 @@
+// src/database/migration/20260312043431_session_message_cursor.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260312043431_session_message_cursor",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DROP INDEX IF EXISTS \`message_session_idx\`;`);
+      yield* tx.run(`DROP INDEX IF EXISTS \`part_message_idx\`;`);
+      yield* tx.run(`CREATE INDEX \`message_session_time_created_id_idx\` ON \`message\` (\`session_id\`,\`time_created\`,\`id\`);`);
+      yield* tx.run(`CREATE INDEX \`part_message_id_id_idx\` ON \`part\` (\`message_id\`,\`id\`);`);
+    });
+  }
+};
+var _20260312043431_session_message_cursor_default = migration;
+
+export { _20260312043431_session_message_cursor_default };

package/dist/chunks/location-mutation-zbqqnp0n.js

@@ -0,0 +1,75 @@
+import {
+  AbsolutePath
+} from "./location-mutation-j07kk359.js";
+
+// src/database/path.ts
+import nodePath from "path";
+import { customType } from "drizzle-orm/sqlite-core";
+import { Schema } from "effect";
+function storagePath(input) {
+  if (process.platform !== "win32")
+    return input;
+  return input.replaceAll("\\", "/");
+}
+function isWindowsStoragePath(input) {
+  return /^[A-Za-z]:\//.test(input) || input.startsWith("//");
+}
+function absolute(input) {
+  const result = storagePath(input);
+  if (!nodePath.posix.isAbsolute(result) && !isWindowsStoragePath(result)) {
+    throw new Error(`Path is not absolute: ${input}`);
+  }
+  return result;
+}
+function toPlatform(input) {
+  if (process.platform !== "win32" || !isWindowsStoragePath(input))
+    return input;
+  return input.replaceAll("/", "\\");
+}
+var absoluteColumn = customType({
+  dataType() {
+    return "text";
+  },
+  toDriver(input) {
+    return absolute(input);
+  },
+  fromDriver(input) {
+    return AbsolutePath.make(toPlatform(absolute(input)));
+  }
+});
+var directoryColumn = customType({
+  dataType() {
+    return "text";
+  },
+  toDriver(input) {
+    return input ? absolute(input) : input;
+  },
+  fromDriver(input) {
+    return input ? toPlatform(absolute(input)) : input;
+  }
+});
+var pathColumn = customType({
+  dataType() {
+    return "text";
+  },
+  toDriver(input) {
+    return storagePath(input);
+  },
+  fromDriver(input) {
+    return storagePath(input);
+  }
+});
+var decodeAbsoluteArray = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Array(Schema.String)));
+var absoluteArrayColumn = customType({
+  dataType() {
+    return "text";
+  },
+  toDriver(input) {
+    return JSON.stringify(input.map(absolute));
+  },
+  fromDriver(input) {
+    return decodeAbsoluteArray(input).map((item) => AbsolutePath.make(toPlatform(absolute(item))));
+  }
+});
+
+export { absoluteColumn, directoryColumn, pathColumn, absoluteArrayColumn };

package/dist/chunks/location-mutation-zdkg1k91.js

@@ -0,0 +1,23 @@
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/location-service-map.ts
+var exports_location_service_map = {};
+__export(exports_location_service_map, {
+  node: () => node,
+  Service: () => Service,
+  LocationServiceMap: () => exports_location_service_map
+});
+import { Context, Effect, Layer } from "effect";
+import { LayerNode } from "@opencode-ai/util/effect/layer-node";
+import { Node } from "@opencode-ai/util/effect/app-node";
+
+class Service extends Context.Service()("@opencode/example/LocationServiceMap") {
+  static get(ref) {
+    return Layer.unwrap(Effect.map(Service, (locations) => locations.get(ref)));
+  }
+}
+var node = LayerNode.unbound(Service, Node.tags.values.global);
+
+export { Service, node, exports_location_service_map };

package/dist/chunks/location-mutation-zfxc0ze5.js

@@ -0,0 +1,123 @@
+import {
+  getTableColumnsRuntime,
+  getTableLikeName,
+  getViewSelectedFieldsRuntime,
+  mapUpdateSet,
+  orderSelectedFields
+} from "./location-mutation-ma07p6tt.js";
+
+// src/database/drizzle/sqlite-core/effect/update.ts
+import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";
+import { entityKind, is } from "drizzle-orm/entity";
+import { SelectionProxyHandler } from "drizzle-orm/selection-proxy";
+import { SQLiteTable } from "drizzle-orm/sqlite-core/table";
+import { extractUsedTable } from "drizzle-orm/sqlite-core/utils";
+import { SQLiteViewBase } from "drizzle-orm/sqlite-core/view-base";
+import { Subquery } from "drizzle-orm/subquery";
+class SQLiteEffectUpdateBuilder {
+  table;
+  session;
+  dialect;
+  withList;
+  static [entityKind] = "SQLiteEffectUpdateBuilder";
+  constructor(table, session, dialect, withList) {
+    this.table = table;
+    this.session = session;
+    this.dialect = dialect;
+    this.withList = withList;
+  }
+  set(values) {
+    return new SQLiteEffectUpdateBase(this.table, mapUpdateSet(this.table, values), this.session, this.dialect, this.withList);
+  }
+}
+
+class SQLiteEffectUpdateBase {
+  effectSession;
+  effectDialect;
+  static [entityKind] = "SQLiteEffectUpdate";
+  config;
+  constructor(table, set, effectSession, effectDialect, withList) {
+    this.effectSession = effectSession;
+    this.effectDialect = effectDialect;
+    this.config = { set, table, withList, joins: [] };
+  }
+  from(source) {
+    this.config.from = source;
+    return this;
+  }
+  createJoin(joinType) {
+    return (table, on) => {
+      const tableName = getTableLikeName(table);
+      if (typeof tableName === "string" && this.config.joins.some((join) => join.alias === tableName)) {
+        throw new Error(`Alias "${tableName}" is already used in this query`);
+      }
+      if (typeof on === "function") {
+        const from = this.config.from ? is(table, SQLiteTable) ? getTableColumnsRuntime(table) : is(table, Subquery) ? table._.selectedFields : is(table, SQLiteViewBase) ? getViewSelectedFieldsRuntime(table).selectedFields : undefined : undefined;
+        on = on(new Proxy(this.config.table._.columns, new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })), from && new Proxy(from, new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })));
+      }
+      this.config.joins.push({ on, table, joinType, alias: tableName });
+      return this;
+    };
+  }
+  leftJoin = this.createJoin("left");
+  rightJoin = this.createJoin("right");
+  innerJoin = this.createJoin("inner");
+  fullJoin = this.createJoin("full");
+  where(where) {
+    this.config.where = where;
+    return this;
+  }
+  orderBy(...columns) {
+    if (typeof columns[0] === "function") {
+      const orderBy = columns[0](new Proxy(getTableColumnsRuntime(this.config.table), new SelectionProxyHandler({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })));
+      this.config.orderBy = Array.isArray(orderBy) ? orderBy : [orderBy];
+      return this;
+    }
+    this.config.orderBy = columns;
+    return this;
+  }
+  limit(limit) {
+    this.config.limit = limit;
+    return this;
+  }
+  returning(fields = getTableColumnsRuntime(this.config.table)) {
+    this.config.returning = orderSelectedFields(fields);
+    return this;
+  }
+  getSQL() {
+    return this.effectDialect.buildUpdateQuery(this.config);
+  }
+  toSQL() {
+    return this.effectDialect.sqlToQuery(this.getSQL());
+  }
+  _prepare(isOneTimeQuery = true) {
+    return this.effectSession[isOneTimeQuery ? "prepareOneTimeQuery" : "prepareQuery"](this.effectDialect.sqlToQuery(this.getSQL()), this.config.returning, this.config.returning ? "all" : "run", undefined, {
+      type: "update",
+      tables: extractUsedTable(this.config.table)
+    });
+  }
+  prepare() {
+    return this._prepare(false);
+  }
+  run = (placeholderValues) => {
+    return this._prepare().run(placeholderValues);
+  };
+  all = (placeholderValues) => {
+    return this._prepare().all(placeholderValues);
+  };
+  get = (placeholderValues) => {
+    return this._prepare().get(placeholderValues);
+  };
+  values = (placeholderValues) => {
+    return this._prepare().values(placeholderValues);
+  };
+  execute = (placeholderValues) => {
+    return this._prepare().execute(placeholderValues);
+  };
+  $dynamic() {
+    return this;
+  }
+}
+applyEffectWrapper(SQLiteEffectUpdateBase);
+
+export { SQLiteEffectUpdateBuilder, SQLiteEffectUpdateBase };

package/dist/chunks/location-mutation-zkhjdecp.js

@@ -0,0 +1,375 @@
+import {
+  exports_runtime
+} from "./location-mutation-jm193w7g.js";
+import {
+  exports_skill
+} from "./location-mutation-js0qxxzx.js";
+import {
+  exports_tool
+} from "./location-mutation-yyhat9md.js";
+import {
+  exports_reference
+} from "./location-mutation-rzy4xjjz.js";
+import {
+  exports_command
+} from "./location-mutation-apjvmrx3.js";
+import {
+  exports_aisdk
+} from "./location-mutation-wqhtb879.js";
+import {
+  exports_agent
+} from "./location-mutation-0ms0v4tv.js";
+import {
+  exports_app
+} from "./location-mutation-50jxp3hw.js";
+import {
+  exports_websearch
+} from "./location-mutation-9m1tawx7.js";
+import {
+  exports_hooks
+} from "./location-mutation-0dwyqmzq.js";
+import {
+  exports_catalog
+} from "./location-mutation-5gvndtda.js";
+import {
+  exports_integration
+} from "./location-mutation-67ww7a6n.js";
+import {
+  exports_credential
+} from "./location-mutation-xvc235nh.js";
+import {
+  exports_model
+} from "./location-mutation-xfd1xnk3.js";
+import {
+  exports_provider
+} from "./location-mutation-d6vvk673.js";
+import {
+  exports_workspace
+} from "./location-mutation-1mtx69dw.js";
+import {
+  exports_location
+} from "./location-mutation-57ntp81p.js";
+import {
+  AbsolutePath
+} from "./location-mutation-j07kk359.js";
+import {
+  exports_bus
+} from "./location-mutation-zz41wrms.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/plugin/host.ts
+var exports_host = {};
+__export(exports_host, {
+  make: () => make,
+  PluginHost: () => exports_host
+});
+import { EventManifest } from "@opencode-ai/schema/event-manifest";
+import { Effect, Schema, Stream } from "effect";
+var mutable = (value) => value;
+var make = Effect.fn("PluginHost.make")(function* (plugin) {
+  const app = yield* exports_app.Metadata;
+  const agents = yield* exports_agent.Service;
+  const aisdk = yield* exports_aisdk.Service;
+  const catalog = yield* exports_catalog.Service;
+  const commands = yield* exports_command.Service;
+  const bus = yield* exports_bus.Service;
+  const integration = yield* exports_integration.Service;
+  const location = yield* exports_location.Service;
+  const reference = yield* exports_reference.Service;
+  const skill = yield* exports_skill.Service;
+  const tools = yield* exports_tool.Service;
+  const websearch = yield* exports_websearch.Service;
+  const hooks = yield* exports_hooks.Service;
+  const runtime = yield* exports_runtime.Service;
+  const locationInfo = () => new exports_location.Info({
+    directory: location.directory,
+    workspaceID: location.workspaceID,
+    project: location.project
+  });
+  const locationRef = (input) => input?.location === undefined ? undefined : exports_location.Ref.make({
+    directory: AbsolutePath.make(input.location.directory ?? location.directory),
+    workspaceID: input.location.workspace === undefined ? location.workspaceID : exports_workspace.ID.make(input.location.workspace)
+  });
+  const isCurrentLocation = (ref) => ref.directory === location.directory && ref.workspaceID === location.workspaceID;
+  const response = (effect) => effect.pipe(Effect.map((data) => ({ location: locationInfo(), data })));
+  return {
+    app,
+    options: {},
+    agent: {
+      get: (input) => {
+        const ref = locationRef(input);
+        const output = ref && !isCurrentLocation(ref) ? runtime.location.agent.list(ref).pipe(Effect.map((result) => ({
+          ...result,
+          data: result.data.find((agent) => agent.id === input.agentID)
+        }))) : response(agents.get(input.agentID));
+        return output.pipe(Effect.flatMap((result) => result.data ? Effect.succeed({ ...result, data: result.data }) : Effect.fail(new Error(`Agent not found: ${input.agentID}`))));
+      },
+      list: (input) => {
+        const ref = locationRef(input);
+        if (ref && !isCurrentLocation(ref))
+          return runtime.location.agent.list(ref);
+        return agents.list().pipe(Effect.map((data) => ({ location: locationInfo(), data })));
+      },
+      reload: agents.reload,
+      transform: (callback) => agents.transform((draft) => {
+        callback({
+          list: () => mutable(draft.list()),
+          get: (id) => mutable(draft.get(exports_agent.ID.make(id))),
+          default: (id) => draft.default(id === undefined ? undefined : exports_agent.ID.make(id)),
+          update: (id, update) => draft.update(exports_agent.ID.make(id), update),
+          remove: (id) => draft.remove(exports_agent.ID.make(id))
+        });
+      })
+    },
+    aisdk: {
+      hook: (name, callback) => {
+        if (name === "sdk") {
+          return aisdk.hook.sdk((event) => {
+            const output = {
+              model: mutable(event.model),
+              package: event.package,
+              options: event.options,
+              sdk: event.sdk
+            };
+            return Reflect.apply(callback, undefined, [output]).pipe(Effect.tap(() => Effect.sync(() => event.sdk = output.sdk)));
+          });
+        }
+        return aisdk.hook.language((event) => {
+          const output = {
+            model: mutable(event.model),
+            options: event.options,
+            sdk: event.sdk,
+            language: event.language
+          };
+          return Reflect.apply(callback, undefined, [output]).pipe(Effect.tap(() => Effect.sync(() => event.language = output.language)));
+        });
+      }
+    },
+    catalog: {
+      provider: {
+        list: () => response(catalog.provider.available()),
+        get: (input) => catalog.provider.get(exports_provider.ID.make(input.providerID)).pipe(Effect.flatMap((provider) => provider === undefined ? Effect.fail(new Error(`Provider not found: ${input.providerID}`)) : response(Effect.succeed(provider))))
+      },
+      model: {
+        list: () => response(catalog.model.available()),
+        default: () => response(catalog.model.default())
+      },
+      reload: catalog.reload,
+      transform: (callback) => catalog.transform((draft) => {
+        callback({
+          provider: {
+            list: () => mutable(draft.provider.list()),
+            get: (id) => mutable(draft.provider.get(exports_provider.ID.make(id))),
+            update: (id, update) => draft.provider.update(exports_provider.ID.make(id), update),
+            remove: (id) => draft.provider.remove(exports_provider.ID.make(id))
+          },
+          model: {
+            get: (providerID, modelID) => mutable(draft.model.get(exports_provider.ID.make(providerID), exports_model.ID.make(modelID))),
+            update: (providerID, modelID, update) => draft.model.update(exports_provider.ID.make(providerID), exports_model.ID.make(modelID), update),
+            remove: (providerID, modelID) => draft.model.remove(exports_provider.ID.make(providerID), exports_model.ID.make(modelID)),
+            default: {
+              get: draft.model.default.get,
+              set: (providerID, modelID) => draft.model.default.set(exports_provider.ID.make(providerID), exports_model.ID.make(modelID))
+            }
+          }
+        });
+      })
+    },
+    command: {
+      list: () => response(commands.list()),
+      reload: commands.reload,
+      transform: (callback) => commands.transform((draft) => {
+        callback(draft);
+      })
+    },
+    event: {
+      subscribe: () => bus.subscribe().pipe(Stream.filter(EventManifest.isServer))
+    },
+    integration: {
+      list: () => response(integration.list()),
+      get: (input) => response(integration.get(exports_integration.ID.make(input.integrationID))),
+      connect: {
+        key: (input) => integration.connection.key({
+          integrationID: exports_integration.ID.make(input.integrationID),
+          key: input.key,
+          answer: input.answer,
+          label: input.label
+        })
+      },
+      oauth: {
+        connect: (input) => response(integration.oauth.connect({
+          integrationID: exports_integration.ID.make(input.integrationID),
+          methodID: exports_integration.MethodID.make(input.methodID),
+          answer: input.answer,
+          label: input.label
+        })),
+        status: (input) => response(integration.oauth.status({
+          integrationID: exports_integration.ID.make(input.integrationID),
+          attemptID: exports_integration.AttemptID.make(input.attemptID)
+        })),
+        complete: (input) => integration.oauth.complete({
+          integrationID: exports_integration.ID.make(input.integrationID),
+          attemptID: exports_integration.AttemptID.make(input.attemptID),
+          code: input.code
+        }),
+        cancel: (input) => integration.oauth.cancel({
+          integrationID: exports_integration.ID.make(input.integrationID),
+          attemptID: exports_integration.AttemptID.make(input.attemptID)
+        })
+      },
+      command: {
+        connect: (input) => response(integration.command.connect({
+          integrationID: exports_integration.ID.make(input.integrationID),
+          methodID: exports_integration.MethodID.make(input.methodID),
+          label: input.label
+        })),
+        status: (input) => response(integration.command.status({
+          integrationID: exports_integration.ID.make(input.integrationID),
+          attemptID: exports_integration.AttemptID.make(input.attemptID)
+        })),
+        cancel: (input) => integration.command.cancel({
+          integrationID: exports_integration.ID.make(input.integrationID),
+          attemptID: exports_integration.AttemptID.make(input.attemptID)
+        })
+      },
+      reload: integration.reload,
+      connection: {
+        active: (id) => integration.connection.active(exports_integration.ID.make(id)),
+        resolve: (connection) => integration.connection.resolve(connection.type === "credential" ? { ...connection, id: exports_credential.ID.make(connection.id) } : connection)
+      },
+      transform: (callback) => integration.transform((draft) => {
+        callback({
+          list: () => mutable(draft.list()),
+          get: (id) => mutable(draft.get(exports_integration.ID.make(id))),
+          update: (id, update) => draft.update(exports_integration.ID.make(id), update),
+          remove: (id) => draft.remove(exports_integration.ID.make(id)),
+          method: {
+            list: (id) => draft.method.list(exports_integration.ID.make(id)),
+            update: (input) => draft.method.update(methodImplementation(input)),
+            remove: (id, method) => draft.method.remove(exports_integration.ID.make(id), Schema.decodeUnknownSync(exports_integration.Method)(method))
+          }
+        });
+      })
+    },
+    plugin: {
+      list: () => response(plugin.list())
+    },
+    reference: {
+      list: () => response(reference.list()),
+      reload: reference.reload,
+      transform: (callback) => reference.transform((draft) => {
+        callback({
+          add: (name, source) => draft.add(name, Schema.decodeUnknownSync(exports_reference.Source)(source)),
+          remove: draft.remove,
+          list: draft.list
+        });
+      })
+    },
+    skill: {
+      list: () => response(skill.list()),
+      reload: skill.reload,
+      transform: (callback) => skill.transform((draft) => {
+        callback({
+          list: () => mutable(draft.list()),
+          add: (value) => draft.add(Schema.decodeUnknownSync(exports_skill.Info)(value)),
+          update: draft.update,
+          remove: draft.remove
+        });
+      })
+    },
+    shell: {
+      hook: (name, callback) => hooks.register("shell", name, callback)
+    },
+    tool: {
+      transform: (callback) => tools.transform((draft) => callback({
+        add: (tool) => draft.add(tool)
+      })).pipe(Effect.orDie, Effect.as({ dispose: Effect.void })),
+      hook: (name, callback) => hooks.register("tool", name, callback)
+    },
+    websearch: {
+      providers: () => response(websearch.providers()),
+      query: (input) => response(websearch.query({
+        query: input.query,
+        providerID: input.providerID === undefined ? undefined : exports_websearch.ID.make(input.providerID)
+      })),
+      reload: websearch.reload,
+      transform: (callback) => websearch.transform((draft) => {
+        callback({
+          add: (definition) => draft.add({
+            id: exports_websearch.ID.make(definition.id),
+            name: definition.name,
+            execute: definition.execute
+          }),
+          default: {
+            get: draft.default.get,
+            set: (selection) => draft.default.set(selection === false || selection === "random" ? selection : exports_websearch.ID.make(selection))
+          }
+        });
+      })
+    },
+    session: {
+      hook: (name, callback) => hooks.register("session", name, callback),
+      create: (input) => runtime.session.create({
+        id: input?.id,
+        title: input?.title,
+        agent: input?.agent,
+        model: input?.model,
+        location: input?.location ?? exports_location.Ref.make({ directory: location.directory, workspaceID: location.workspaceID })
+      }),
+      get: (input) => runtime.session.get(input.sessionID),
+      prompt: runtime.session.prompt,
+      generate: (input) => runtime.session.generate(input).pipe(Effect.map((text) => ({ text }))),
+      command: runtime.session.command,
+      rename: runtime.session.rename,
+      synthetic: runtime.session.synthetic,
+      interrupt: (input) => runtime.session.interrupt(input.sessionID),
+      wait: (input) => runtime.session.wait(input.sessionID)
+    }
+  };
+});
+function methodImplementation(input) {
+  if ("authorize" in input) {
+    const refresh = input.refresh;
+    return {
+      integrationID: exports_integration.ID.make(input.integrationID),
+      method: { ...input.method, id: exports_integration.MethodID.make(input.method.id) },
+      authorize: (answer) => input.authorize(answer).pipe(Effect.map((authorization) => {
+        if (authorization.mode === "auto") {
+          return {
+            ...authorization,
+            callback: authorization.callback.pipe(Effect.map(credential))
+          };
+        }
+        return {
+          ...authorization,
+          callback: (code) => authorization.callback(code).pipe(Effect.map(credential))
+        };
+      })),
+      ...refresh ? { refresh: (value) => refresh(value).pipe(Effect.map(credential)) } : {},
+      ...input.label ? { label: input.label } : {}
+    };
+  }
+  if (input.method.type === "env") {
+    return {
+      integrationID: exports_integration.ID.make(input.integrationID),
+      method: input.method
+    };
+  }
+  if (input.method.type === "command") {
+    return {
+      integrationID: exports_integration.ID.make(input.integrationID),
+      method: { ...input.method, id: exports_integration.MethodID.make(input.method.id) }
+    };
+  }
+  return {
+    integrationID: exports_integration.ID.make(input.integrationID),
+    method: input.method
+  };
+}
+function credential(value) {
+  return exports_credential.OAuth.make({ ...value, methodID: exports_integration.MethodID.make(value.methodID) });
+}
+
+export { make, exports_host };