@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-f9e3yxsz.js

@@ -0,0 +1,72 @@
+import {
+  exports_config
+} from "./permission-k59zb4v2.js";
+import {
+  exports_watcher
+} from "./permission-a3xgesk5.js";
+import {
+  exports_bus
+} from "./permission-r5ce0emk.js";
+import {
+  exports_location
+} from "./permission-1e2ryyac.js";
+import {
+  exports_git
+} from "./permission-z66vzcey.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/filesystem/location-watcher.ts
+var exports_location_watcher = {};
+__export(exports_location_watcher, {
+  node: () => node,
+  Service: () => Service,
+  LocationWatcher: () => exports_location_watcher
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Context, Effect, Layer, Stream } from "effect";
+import { FileSystem } from "@opencode-ai/schema/filesystem";
+import path from "path";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+class Service extends Context.Service()("@opencode/LocationWatcher") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const location = yield* exports_location.Service;
+  const watcher = yield* exports_watcher.Service;
+  const bus = yield* exports_bus.Service;
+  const fs = yield* FSUtil.Service;
+  const git = yield* exports_git.Service;
+  const configService = yield* exports_config.Service;
+  const publish = (update) => bus.publish(FileSystem.Event.Changed, {
+    file: update.path,
+    event: update.type === "create" ? "add" : update.type === "update" ? "change" : "unlink"
+  });
+  yield* Effect.gen(function* () {
+    const config = (yield* configService.entries()).filter((entry) => entry.type === "document").flatMap((item) => item.info.watcher?.ignore ?? []);
+    if (location.vcs?.type === "git") {
+      const resolved = (yield* git.repo.discover(location.directory))?.gitDirectory;
+      const vcs = resolved ? yield* fs.realPath(resolved).pipe(Effect.catch(() => Effect.succeed(resolved))) : undefined;
+      if (vcs && !config.includes(".git") && !config.includes(vcs) && (!resolved || !config.includes(resolved))) {
+        const updates = yield* watcher.subscribe({ path: path.join(vcs, "HEAD"), type: "file" });
+        yield* updates.pipe(Stream.runForEach(publish), Effect.forkScoped);
+      }
+    }
+    if (location.vcs?.type === "hg") {
+      const store = location.vcs.store;
+      const vcs = yield* fs.realPath(store).pipe(Effect.catch(() => Effect.succeed(store)));
+      if (!config.includes(".hg") && !config.includes(vcs)) {
+        const updates = yield* watcher.subscribe({ path: path.join(vcs, "branch"), type: "file" });
+        yield* updates.pipe(Stream.runForEach(publish), Effect.forkScoped);
+      }
+    }
+  }).pipe(Effect.withSpan("LocationWatcher.start", { attributes: { directory: location.directory } }), Effect.catchCause((cause) => Effect.logError("failed to init location watcher service", { cause })), Effect.forkScoped);
+  return Service.of({});
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [exports_watcher.node, FSUtil.node, exports_location.node, exports_config.node, exports_git.node, exports_bus.node]
+});
+
+export { Service, node, exports_location_watcher };

package/dist/chunks/permission-faypg4r1.js

@@ -0,0 +1,13 @@
+// src/database/migration/20260428004200_add_session_path.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260428004200_add_session_path",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`session\` ADD \`path\` text;`);
+    });
+  }
+};
+var _20260428004200_add_session_path_default = migration;
+
+export { _20260428004200_add_session_path_default };

package/dist/chunks/permission-fj3fqzqb.js

@@ -0,0 +1,175 @@
+import {
+  exports_page
+} from "./permission-7mrpdsq5.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/mcp/oauth.ts
+var exports_oauth = {};
+__export(exports_oauth, {
+  toTokens: () => toTokens,
+  toCredential: () => toCredential,
+  provider: () => provider,
+  memoryStore: () => memoryStore,
+  clientFromCredential: () => clientFromCredential,
+  authorize: () => authorize,
+  MCPOAuth: () => exports_oauth
+});
+import { auth } from "@modelcontextprotocol/sdk/client/auth.js";
+import { createServer } from "node:http";
+import { Deferred, Effect } from "effect";
+import { Credential } from "@opencode-ai/schema/credential";
+var provider = (options) => {
+  const state = options.state;
+  const client = options.client;
+  return {
+    redirectUrl: options.redirectUrl,
+    clientMetadata: {
+      redirect_uris: [options.redirectUrl],
+      client_name: "opencode",
+      client_uri: "https://opencode.ai",
+      grant_types: ["authorization_code", "refresh_token"],
+      response_types: ["code"],
+      token_endpoint_auth_method: client?.secret ? "client_secret_post" : "none",
+      ...options.scope ? { scope: options.scope } : {}
+    },
+    ...state !== undefined ? { state: () => state } : {},
+    clientInformation: () => client ? { client_id: client.id, client_secret: client.secret } : options.store.clientInformation(),
+    saveClientInformation: (info) => options.store.saveClientInformation(info),
+    tokens: () => options.store.tokens(),
+    saveTokens: (tokens) => options.store.saveTokens(tokens),
+    redirectToAuthorization: (url) => options.onRedirect(url),
+    ...options.invalidate ? { invalidateCredentials: options.invalidate } : {},
+    saveCodeVerifier: (verifier) => options.store.saveCodeVerifier(verifier),
+    codeVerifier: async () => {
+      const verifier = await options.store.codeVerifier();
+      if (!verifier)
+        throw new Error("Missing PKCE code verifier for MCP OAuth flow");
+      return verifier;
+    }
+  };
+};
+var memoryStore = () => {
+  let tokens;
+  let client;
+  let verifier;
+  return {
+    tokens: async () => tokens,
+    saveTokens: async (value) => {
+      tokens = value;
+    },
+    clientInformation: async () => client,
+    saveClientInformation: async (value) => {
+      client = value;
+    },
+    codeVerifier: async () => verifier,
+    saveCodeVerifier: async (value) => {
+      verifier = value;
+    }
+  };
+};
+var clientFromCredential = (credential) => credential.metadata?.client;
+var toCredential = (input) => Credential.OAuth.make({
+  type: "oauth",
+  methodID: input.methodID,
+  access: input.tokens.access_token,
+  refresh: input.tokens.refresh_token ?? "",
+  expires: input.tokens.expires_in ? Date.now() + input.tokens.expires_in * 1000 : 0,
+  metadata: {
+    serverUrl: input.serverUrl,
+    tokenType: input.tokens.token_type,
+    ...input.tokens.scope ? { scope: input.tokens.scope } : {},
+    ...input.client ? { client: input.client } : {}
+  }
+});
+var toTokens = (credential) => {
+  const metadata = credential.metadata ?? {};
+  return {
+    access_token: credential.access,
+    token_type: typeof metadata.tokenType === "string" ? metadata.tokenType : "Bearer",
+    ...credential.refresh ? { refresh_token: credential.refresh } : {},
+    ...credential.expires ? { expires_in: Math.max(0, Math.floor((credential.expires - Date.now()) / 1000)) } : {},
+    ...typeof metadata.scope === "string" ? { scope: metadata.scope } : {}
+  };
+};
+var authorize = (input) => Effect.gen(function* () {
+  const oauth = input.config.oauth || undefined;
+  const store = memoryStore();
+  const code = yield* Deferred.make();
+  const redirectPath = oauth?.redirect_uri ? new URL(oauth.redirect_uri).pathname : "/callback";
+  const state = Buffer.from(crypto.getRandomValues(new Uint8Array(32))).toString("base64url");
+  const server = createServer((request, response) => {
+    const url = new URL(request.url ?? "/", "http://127.0.0.1");
+    if (url.pathname !== redirectPath) {
+      response.writeHead(404).end("Not found");
+      return;
+    }
+    const fail = (reason) => {
+      Effect.runFork(Deferred.fail(code, new Error(reason)));
+      response.writeHead(400, { "Content-Type": "text/html" }).end(exports_page.error(reason, { provider: input.name }));
+    };
+    const error = url.searchParams.get("error_description") ?? url.searchParams.get("error");
+    if (error)
+      return fail(error);
+    if (url.searchParams.get("state") !== state)
+      return fail("OAuth state mismatch");
+    const value = url.searchParams.get("code");
+    if (!value)
+      return fail("Missing authorization code");
+    Effect.runFork(Deferred.succeed(code, value));
+    response.writeHead(200, { "Content-Type": "text/html" }).end(exports_page.success({ provider: input.name }));
+  });
+  const redirectPort = oauth?.redirect_uri ? Number(new URL(oauth.redirect_uri).port) || undefined : undefined;
+  const port = yield* Effect.callback((resume) => {
+    server.once("error", (error) => resume(Effect.fail(error)));
+    server.listen(oauth?.callback_port ?? redirectPort ?? 0, "127.0.0.1", () => {
+      const address = server.address();
+      resume(address && typeof address === "object" ? Effect.succeed(address.port) : Effect.fail(new Error("Could not determine MCP OAuth callback port")));
+    });
+  });
+  yield* Effect.addFinalizer(() => Effect.sync(() => server.close()));
+  let authorizationUrl;
+  const oauthProvider = provider({
+    redirectUrl: oauth?.redirect_uri ?? `http://127.0.0.1:${port}${redirectPath}`,
+    scope: oauth?.scope,
+    state,
+    client: oauth?.client_id ? { id: oauth.client_id, secret: oauth.client_secret } : undefined,
+    onRedirect: (url) => {
+      authorizationUrl = url;
+    },
+    store
+  });
+  const finalize = Effect.gen(function* () {
+    const tokens = yield* Effect.promise(() => store.tokens());
+    if (!tokens)
+      return yield* Effect.fail(new Error(`MCP server "${input.name}" did not return OAuth tokens`));
+    const client = yield* Effect.promise(() => store.clientInformation());
+    return toCredential({ methodID: input.methodID, serverUrl: input.config.url, tokens, client });
+  });
+  const result = yield* Effect.tryPromise({
+    try: () => auth(oauthProvider, { serverUrl: input.config.url, scope: oauth?.scope }),
+    catch: (error) => error instanceof Error ? error : new Error(String(error))
+  });
+  if (result === "AUTHORIZED") {
+    return {
+      url: input.config.url,
+      instructions: `Connected to ${input.name}.`,
+      mode: "auto",
+      callback: finalize
+    };
+  }
+  if (!authorizationUrl)
+    return yield* Effect.fail(new Error(`MCP server "${input.name}" did not provide an authorization URL`));
+  return {
+    url: authorizationUrl.toString(),
+    instructions: `Authorize ${input.name} in your browser. This window will close automatically.`,
+    mode: "auto",
+    callback: Deferred.await(code).pipe(Effect.flatMap((value) => Effect.tryPromise({
+      try: () => auth(oauthProvider, { serverUrl: input.config.url, authorizationCode: value, scope: oauth?.scope }),
+      catch: (error) => error instanceof Error ? error : new Error(String(error))
+    })), Effect.flatMap(() => finalize))
+  };
+});
+
+export { provider, memoryStore, clientFromCredential, toCredential, toTokens, authorize, exports_oauth };

package/dist/chunks/permission-fm1nvm5g.js

@@ -0,0 +1,32 @@
+import {
+  exports_provider
+} from "./permission-d6vvk673.js";
+
+// src/plugin/provider/nvidia.ts
+import { Effect } from "effect";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+var NvidiaPlugin = 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))
+          continue;
+        if (exports_provider.packageName(item.provider.package) !== "@ai-sdk/openai-compatible")
+          continue;
+        if (item.provider.settings?.baseURL !== "https://integrate.api.nvidia.com/v1")
+          continue;
+        evt.provider.update(item.provider.id, (provider) => {
+          provider.headers = {
+            ...provider.headers,
+            "HTTP-Referer": "https://opencode.ai/",
+            "X-Title": "opencode",
+            "X-BILLING-INVOKE-ORIGIN": provider.headers?.["X-BILLING-INVOKE-ORIGIN"] ?? "OpenCode"
+          };
+        });
+      }
+    });
+  })
+});
+
+export { NvidiaPlugin };

package/dist/chunks/permission-fmyre8m1.js

@@ -0,0 +1,24 @@
+import {
+  __require
+} from "./permission-rvfvac9x.js";
+
+// src/plugin/provider/openai-compatible.ts
+import { Effect } from "effect";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+var OpenAICompatiblePlugin = define({
+  id: "opencode.provider.openai-compatible",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+      if (evt.sdk)
+        return;
+      if (!evt.package.includes("@ai-sdk/openai-compatible"))
+        return;
+      if (evt.options.includeUsage !== false)
+        evt.options.includeUsage = true;
+      const mod = yield* Effect.promise(() => import("@ai-sdk/openai-compatible"));
+      evt.sdk = mod.createOpenAICompatible(evt.options);
+    }));
+  })
+});
+
+export { OpenAICompatiblePlugin };

package/dist/chunks/permission-g7k9te92.js

@@ -0,0 +1,15 @@
+// src/util/which.ts
+import whichPkg from "which";
+import path from "path";
+function which(cmd, env, bin) {
+  const base = env?.PATH ?? env?.Path ?? process.env.PATH ?? process.env.Path ?? "";
+  const full = base && bin ? base + path.delimiter + bin : base || bin;
+  const result = whichPkg.sync(cmd, {
+    nothrow: true,
+    path: full,
+    pathExt: env?.PATHEXT ?? env?.PathExt ?? process.env.PATHEXT ?? process.env.PathExt
+  });
+  return typeof result === "string" ? result : null;
+}
+
+export { which };

package/dist/chunks/permission-g9yygpzr.js

@@ -0,0 +1,80 @@
+import {
+  getTableColumnsRuntime,
+  orderSelectedFields
+} from "./permission-ma07p6tt.js";
+
+// src/database/drizzle/sqlite-core/effect/delete.ts
+import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";
+import { entityKind } from "drizzle-orm/entity";
+import { SelectionProxyHandler } from "drizzle-orm/selection-proxy";
+import { extractUsedTable } from "drizzle-orm/sqlite-core/utils";
+class SQLiteEffectDeleteBase {
+  table;
+  effectSession;
+  effectDialect;
+  static [entityKind] = "SQLiteEffectDelete";
+  config;
+  constructor(table, effectSession, effectDialect, withList) {
+    this.table = table;
+    this.effectSession = effectSession;
+    this.effectDialect = effectDialect;
+    this.config = { table, withList };
+  }
+  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.table)) {
+    this.config.returning = orderSelectedFields(fields);
+    return this;
+  }
+  getSQL() {
+    return this.effectDialect.buildDeleteQuery(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: "delete",
+      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(SQLiteEffectDeleteBase);
+
+export { SQLiteEffectDeleteBase };

package/dist/chunks/permission-gcay93cp.js

@@ -0,0 +1,14 @@
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/v1/config/layout.ts
+var exports_layout = {};
+__export(exports_layout, {
+  Layout: () => Layout,
+  ConfigLayoutV1: () => exports_layout
+});
+import { Schema } from "effect";
+var Layout = Schema.Literals(["auto", "stretch"]).annotate({ identifier: "LayoutConfig" });
+
+export { Layout, exports_layout };

package/dist/chunks/permission-gd2xppx8.js

@@ -0,0 +1,14 @@
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/file.ts
+var exports_file = {};
+__export(exports_file, {
+  File: () => exports_file,
+  Diff: () => Diff
+});
+import { FileDiff } from "@opencode-ai/schema/file-diff";
+var Diff = FileDiff.Info;
+
+export { Diff, exports_file };

package/dist/chunks/permission-gd5xeqc2.js

@@ -0,0 +1,32 @@
+// src/database/migration/20260228203230_blue_harpoon.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260228203230_blue_harpoon",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`account\` (
+          \`id\` text PRIMARY KEY,
+          \`email\` text NOT NULL,
+          \`url\` text NOT NULL,
+          \`access_token\` text NOT NULL,
+          \`refresh_token\` text NOT NULL,
+          \`token_expiry\` integer,
+          \`selected_org_id\` text,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL
+        );
+      `);
+      yield* tx.run(`
+        CREATE TABLE \`account_state\` (
+          \`id\` integer PRIMARY KEY NOT NULL,
+          \`active_account_id\` text,
+          FOREIGN KEY (\`active_account_id\`) REFERENCES \`account\`(\`id\`) ON UPDATE no action ON DELETE set null
+        );
+      `);
+    });
+  }
+};
+var _20260228203230_blue_harpoon_default = migration;
+
+export { _20260228203230_blue_harpoon_default };

package/dist/chunks/permission-ghm4673n.js

@@ -0,0 +1,27 @@
+// src/database/migration/20260611192811_lush_chimera.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260611192811_lush_chimera",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DROP INDEX IF EXISTS \`credential_connector_active_idx\`;`);
+      yield* tx.run(`DROP TABLE \`credential\`;`);
+      yield* tx.run(`
+        CREATE TABLE \`credential\` (
+          \`id\` text PRIMARY KEY,
+          \`integration_id\` text,
+          \`label\` text NOT NULL,
+          \`value\` text NOT NULL,
+          \`connector_id\` text,
+          \`method_id\` text,
+          \`active\` integer,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL
+        );
+      `);
+    });
+  }
+};
+var _20260611192811_lush_chimera_default = migration;
+
+export { _20260611192811_lush_chimera_default };

package/dist/chunks/permission-ghwjy7my.js

@@ -0,0 +1,41 @@
+// src/database/migration/20260604172448_event_sourced_session_input.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260604172448_event_sourced_session_input",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DELETE FROM \`session_input\`;`);
+      yield* tx.run(`DELETE FROM \`session_message\`;`);
+      yield* tx.run(`DELETE FROM \`event\`;`);
+      yield* tx.run(`DELETE FROM \`event_sequence\`;`);
+      yield* tx.run(`UPDATE \`session\` SET \`workspace_id\` = NULL;`);
+      yield* tx.run(`DELETE FROM \`workspace\`;`);
+      yield* tx.run(`DROP INDEX IF EXISTS \`event_aggregate_seq_idx\`;`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`event_aggregate_seq_idx\` ON \`event\` (\`aggregate_id\`,\`seq\`);`);
+      yield* tx.run(`DROP INDEX IF EXISTS \`session_message_session_seq_idx\`;`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`session_message_session_seq_idx\` ON \`session_message\` (\`session_id\`,\`seq\`);`);
+      yield* tx.run(`PRAGMA foreign_keys=OFF;`);
+      yield* tx.run(`
+        CREATE TABLE \`__new_session_input\` (
+          \`id\` text PRIMARY KEY,
+          \`session_id\` text NOT NULL,
+          \`prompt\` text NOT NULL,
+          \`delivery\` text NOT NULL,
+          \`admitted_seq\` integer NOT NULL,
+          \`promoted_seq\` integer,
+          \`time_created\` integer NOT NULL,
+          CONSTRAINT \`fk_session_input_session_id_session_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`DROP TABLE \`session_input\`;`);
+      yield* tx.run(`ALTER TABLE \`__new_session_input\` RENAME TO \`session_input\`;`);
+      yield* tx.run(`PRAGMA foreign_keys=ON;`);
+      yield* tx.run(`CREATE INDEX \`session_input_session_pending_delivery_seq_idx\` ON \`session_input\` (\`session_id\`,\`promoted_seq\`,\`delivery\`,\`admitted_seq\`);`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`session_input_session_admitted_seq_idx\` ON \`session_input\` (\`session_id\`,\`admitted_seq\`);`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`session_input_session_promoted_seq_idx\` ON \`session_input\` (\`session_id\`,\`promoted_seq\`);`);
+    });
+  }
+};
+var _20260604172448_event_sourced_session_input_default = migration;
+
+export { _20260604172448_event_sourced_session_input_default };

package/dist/chunks/permission-gm8kdh5e.js

@@ -0,0 +1,39 @@
+import {
+  AbsolutePath
+} from "./permission-j07kk359.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/project/schema.ts
+var exports_schema = {};
+__export(exports_schema, {
+  Vcs: () => Vcs,
+  ProjectSchema: () => exports_schema,
+  Info: () => Info,
+  ID: () => ID,
+  Directory: () => Directory,
+  DirectoriesInput: () => DirectoriesInput,
+  Directories: () => Directories,
+  Current: () => Current
+});
+import { Schema } from "effect";
+import { Project } from "@opencode-ai/schema/project";
+var ID = Project.ID;
+var Current = Project.Current;
+var Directory = Project.Directory;
+var Info = Project.Info;
+var DirectoriesInput = Project.DirectoriesInput;
+var Directories = Project.Directories;
+var Vcs = Schema.Union([
+  Schema.Struct({
+    type: Schema.Literal("git"),
+    store: AbsolutePath
+  }),
+  Schema.Struct({
+    type: Schema.Literal("hg"),
+    store: AbsolutePath
+  })
+]);
+
+export { ID, Current, Directory, Info, DirectoriesInput, Directories, Vcs, exports_schema };