@opencode-ai/core 0.0.0-dev-17471

package/dist/chunks/location-mutation-1kvtxahz.js

@@ -0,0 +1,175 @@
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/repository.ts
+var exports_repository = {};
+__export(exports_repository, {
+  validateBranch: () => validateBranch,
+  same: () => same,
+  parseRemote: () => parseRemote,
+  parse: () => parse,
+  isRemote: () => isRemote,
+  isFile: () => isFile,
+  cachePath: () => cachePath,
+  cacheIdentity: () => cacheIdentity,
+  UnsupportedLocalRepositoryError: () => UnsupportedLocalRepositoryError,
+  Repository: () => exports_repository,
+  InvalidReferenceError: () => InvalidReferenceError,
+  InvalidBranchError: () => InvalidBranchError
+});
+import path from "path";
+import { fileURLToPath } from "url";
+import { Schema } from "effect";
+
+class InvalidReferenceError extends Schema.TaggedErrorClass()("RepositoryInvalidReferenceError", {
+  repository: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class UnsupportedLocalRepositoryError extends Schema.TaggedErrorClass()("RepositoryUnsupportedLocalRepositoryError", {
+  repository: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class InvalidBranchError extends Schema.TaggedErrorClass()("RepositoryInvalidBranchError", {
+  branch: Schema.String,
+  message: Schema.String
+}) {
+}
+function parse(input) {
+  const cleaned = normalizeInput(input);
+  if (!cleaned)
+    return;
+  const githubPrefixed = cleaned.match(/^github:([^/\s]+)\/([^/\s]+)$/);
+  if (githubPrefixed)
+    return buildRemote({ host: "github.com", segments: [githubPrefixed[1], githubPrefixed[2]] });
+  if (!cleaned.includes("://")) {
+    const scp = cleaned.match(/^(?:[^@/\s]+@)?([^:/\s]+):(.+)$/);
+    if (scp)
+      return buildRemote({ host: scp[1], segments: parts(scp[2]), remote: cleaned });
+    const direct = parts(cleaned);
+    if (direct.length >= 2 && hostLike(direct[0]))
+      return buildRemote({ host: direct[0], segments: direct.slice(1) });
+    if (direct.length === 2)
+      return buildRemote({ host: "github.com", segments: direct });
+  }
+  try {
+    const url = new URL(cleaned);
+    if (url.protocol === "file:")
+      return buildFile({ url, remote: cleaned });
+    const segments = parts(url.pathname);
+    return buildRemote({
+      host: url.host,
+      segments,
+      remote: url.host === "github.com" ? githubRemote(segments.join("/")) : cleaned,
+      protocol: url.protocol
+    });
+  } catch {
+    return;
+  }
+}
+function parseRemote(input) {
+  const reference = parse(input);
+  if (!reference) {
+    throw new InvalidReferenceError({
+      repository: input,
+      message: "Repository must be a git URL, host/path reference, or GitHub owner/repo shorthand"
+    });
+  }
+  if (!isRemote(reference)) {
+    throw new UnsupportedLocalRepositoryError({
+      repository: input,
+      message: "Local file repositories are not supported"
+    });
+  }
+  return reference;
+}
+function validateBranch(branch) {
+  if (/^[A-Za-z0-9/_.-]+$/.test(branch) && !branch.startsWith("-") && !branch.includes(".."))
+    return;
+  throw new InvalidBranchError({
+    branch,
+    message: "Branch must contain only alphanumeric characters, /, _, ., and -, and cannot start with - or contain .."
+  });
+}
+function isFile(reference) {
+  return reference.protocol === "file:";
+}
+function isRemote(reference) {
+  return !isFile(reference);
+}
+function cachePath(root, reference, branch) {
+  const base = path.join(root, ...reference.host.split(":"), ...reference.segments);
+  return branch ? `${base}@${encodeURIComponent(branch)}` : base;
+}
+function cacheIdentity(reference) {
+  return `${reference.host}/${reference.path}`;
+}
+function same(left, right) {
+  return cacheIdentity(left) === cacheIdentity(right);
+}
+function normalizeInput(input) {
+  return input.trim().replace(/^git\+/, "").replace(/#.*$/, "").replace(/\/+$/, "");
+}
+function trimGitSuffix(input) {
+  return input.replace(/\.git$/, "");
+}
+function parts(input) {
+  return input.split("/").map((item) => trimGitSuffix(item.trim())).filter(Boolean);
+}
+function safeHost(input) {
+  return Boolean(input) && !input.startsWith("-") && !/[\s/\\]/.test(input);
+}
+function safeSegment(input) {
+  return input !== "." && input !== ".." && !input.includes(":") && !/[\s/\\]/.test(input);
+}
+function hostLike(input) {
+  return input.includes(".") || input.includes(":") || input === "localhost";
+}
+function withSlash(input) {
+  return input.endsWith("/") ? input : `${input}/`;
+}
+function githubRemote(pathname) {
+  const base = process.env.OPENCODE_REPO_CLONE_GITHUB_BASE_URL;
+  if (!base)
+    return `https://github.com/${pathname}.git`;
+  return new URL(`${pathname}.git`, withSlash(base)).href;
+}
+function buildRemote(input) {
+  const segments = input.segments.map(trimGitSuffix).filter(Boolean);
+  if (!safeHost(input.host) || !segments.length || segments.some((segment) => !safeSegment(segment)))
+    return;
+  const repositoryPath = segments.join("/");
+  const host = input.host.toLowerCase();
+  return {
+    host,
+    path: repositoryPath,
+    segments,
+    owner: segments.length === 2 ? segments[0] : undefined,
+    repo: segments[segments.length - 1],
+    remote: input.remote ?? (host === "github.com" ? githubRemote(repositoryPath) : `https://${host}/${repositoryPath}.git`),
+    label: host === "github.com" && segments.length === 2 ? repositoryPath : `${host}/${repositoryPath}`,
+    protocol: input.protocol
+  };
+}
+function buildFile(input) {
+  const filePath = path.normalize(fileURLToPath(input.url));
+  const segments = filePath.split(/[\\/]+/).filter(Boolean);
+  if (!segments.length)
+    return;
+  return {
+    host: "file",
+    path: filePath,
+    segments: segments.map((segment) => segment.replace(/:$/, "")),
+    owner: undefined,
+    repo: trimGitSuffix(segments[segments.length - 1]),
+    remote: input.remote,
+    label: filePath,
+    protocol: "file:"
+  };
+}
+
+export { InvalidReferenceError, UnsupportedLocalRepositoryError, InvalidBranchError, parse, parseRemote, validateBranch, isFile, isRemote, cachePath, cacheIdentity, same, exports_repository };

package/dist/chunks/location-mutation-1mtx69dw.js

@@ -0,0 +1,153 @@
+import {
+  exports_driver
+} from "./location-mutation-2m0g72hh.js";
+import {
+  WorkspaceTable
+} from "./location-mutation-3c4nztf9.js";
+import {
+  exports_database
+} from "./location-mutation-j0ksmf2f.js";
+import {
+  exports_keyed_mutex
+} from "./location-mutation-0kvmztkf.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/workspace.ts
+var exports_workspace = {};
+__export(exports_workspace, {
+  node: () => node,
+  configured: () => configured,
+  Workspace: () => exports_workspace,
+  Service: () => Service,
+  NotFound: () => NotFound,
+  Info: () => Info,
+  ID: () => ID
+});
+import { Workspace } from "@opencode-ai/schema/workspace";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+import { eq } from "drizzle-orm";
+import { Clock, Context, Duration, Effect, Exit, Layer, Ref, Schedule, Schema, Scope } from "effect";
+import { systemError } from "effect/PlatformError";
+import { make } from "effect/unstable/process/ChildProcessSpawner";
+var ID = Workspace.ID;
+
+class Info extends Schema.Class("Workspace.Info")({
+  id: ID,
+  provider: Schema.String,
+  binding: exports_driver.Binding,
+  createdAt: Schema.Number,
+  lastUsedAt: Schema.Number
+}) {
+}
+
+class NotFound extends Schema.TaggedErrorClass()("Workspace.NotFound", { workspaceID: ID }) {
+}
+
+class Service extends Context.Service()("@opencode/Workspace") {
+}
+var configured = (options = {}) => makeGlobalNode({
+  service: Service,
+  layer: layer(options),
+  deps: [exports_database.node, exports_driver.node]
+});
+var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
+  const db = (yield* exports_database.Service).db;
+  const registry = yield* exports_driver.RegistryService;
+  const lifetime = yield* Scope.Scope;
+  const connections = new Map;
+  const locks = exports_keyed_mutex.makeUnsafe();
+  const idleThreshold = Duration.toMillis(options.idleThreshold ?? Duration.minutes(20));
+  const load = Effect.fn("Workspace.load")(function* (workspaceID) {
+    const row = yield* db.select().from(WorkspaceTable).where(eq(WorkspaceTable.id, workspaceID)).get().pipe(Effect.orDie);
+    if (!row)
+      return yield* new NotFound({ workspaceID });
+    return row;
+  });
+  const open = Effect.fn("Workspace.open")(function* (workspaceID) {
+    const existing = connections.get(workspaceID);
+    if (existing)
+      return existing;
+    const row = yield* load(workspaceID);
+    const driver = yield* registry.get(row.provider);
+    const saveBinding = (value) => db.update(WorkspaceTable).set({ binding: value }).where(eq(WorkspaceTable.id, workspaceID)).run().pipe(Effect.orDie);
+    const scope = yield* Scope.fork(lifetime);
+    const environment = yield* driver.connect({ workspaceID, binding: row.binding, saveBinding }).pipe(Effect.provideService(Scope.Scope, scope), Effect.onError((cause) => Scope.close(scope, Exit.failCause(cause))));
+    const now = yield* Clock.currentTimeMillis;
+    const connection = {
+      driver,
+      environment,
+      saveBinding,
+      lastActivity: yield* Ref.make(now),
+      active: yield* Ref.make(0),
+      scope
+    };
+    connections.set(workspaceID, connection);
+    yield* db.update(WorkspaceTable).set({ last_used_at: now }).where(eq(WorkspaceTable.id, workspaceID)).run().pipe(Effect.orDie);
+    return connection;
+  });
+  yield* Effect.gen(function* () {
+    const now = yield* Clock.currentTimeMillis;
+    yield* Effect.forEach([...connections.entries()], ([workspaceID, expected]) => locks.withLock(workspaceID)(Effect.gen(function* () {
+      const connection = connections.get(workspaceID);
+      if (connection !== expected || (yield* Ref.get(connection.active)) > 0)
+        return;
+      const lastActivity = yield* Ref.get(connection.lastActivity);
+      if (now - lastActivity < idleThreshold)
+        return;
+      const row = yield* load(workspaceID);
+      yield* connection.driver.suspendForIdle({
+        workspaceID,
+        binding: row.binding,
+        saveBinding: connection.saveBinding
+      });
+      yield* db.update(WorkspaceTable).set({ last_used_at: lastActivity }).where(eq(WorkspaceTable.id, workspaceID)).run().pipe(Effect.orDie);
+      connections.delete(workspaceID);
+      yield* Scope.close(connection.scope, Exit.void);
+    }).pipe(Effect.catchCause((cause) => Effect.logError("workspace idle suspension failed", cause)))), { concurrency: "unbounded", discard: true });
+  }).pipe(Effect.repeat(Schedule.spaced(options.pollInterval ?? Duration.minutes(1))), Effect.forkScoped);
+  return Service.of({
+    create: Effect.fn("Workspace.create")(function* (provider) {
+      const driver = yield* registry.get(provider);
+      const workspaceID = ID.create();
+      const result = yield* driver.create({ workspaceID });
+      const now = yield* Clock.currentTimeMillis;
+      yield* db.insert(WorkspaceTable).values({ id: workspaceID, provider, binding: result.binding, created_at: now, last_used_at: now }).run().pipe(Effect.orDie);
+      return new Info({ id: workspaceID, provider, binding: result.binding, createdAt: now, lastUsedAt: now });
+    }),
+    connect: Effect.fn("Workspace.connect")(function* (workspaceID) {
+      const spawner = make((command) => Effect.acquireRelease(locks.withLock(workspaceID)(Effect.gen(function* () {
+        const connection = yield* open(workspaceID).pipe(Effect.mapError((cause) => systemError({
+          _tag: "Unknown",
+          module: "Workspace",
+          method: "spawn",
+          description: `Failed to wake workspace ${workspaceID}`,
+          cause
+        })));
+        yield* Ref.set(connection.lastActivity, yield* Clock.currentTimeMillis);
+        yield* Ref.update(connection.active, (active) => active + 1);
+        return connection;
+      })), (connection) => locks.withLock(workspaceID)(Effect.gen(function* () {
+        yield* Ref.update(connection.active, (active) => active - 1);
+        yield* Ref.set(connection.lastActivity, yield* Clock.currentTimeMillis);
+      }))).pipe(Effect.flatMap((connection) => connection.environment.spawner.spawn(command))));
+      return { spawner };
+    }),
+    destroy: Effect.fn("Workspace.destroy")(function* (workspaceID) {
+      yield* locks.withLock(workspaceID)(Effect.gen(function* () {
+        const row = yield* load(workspaceID);
+        const connection = connections.get(workspaceID);
+        connections.delete(workspaceID);
+        if (connection)
+          yield* Scope.close(connection.scope, Exit.void);
+        const driver = yield* registry.get(row.provider);
+        yield* driver.destroy({ workspaceID, binding: row.binding });
+        yield* db.delete(WorkspaceTable).where(eq(WorkspaceTable.id, workspaceID)).run().pipe(Effect.orDie);
+      }));
+    })
+  });
+}));
+var node = configured();
+
+export { ID, Info, NotFound, Service, configured, node, exports_workspace };

package/dist/chunks/location-mutation-1wcz8fvj.js

@@ -0,0 +1,16 @@
+// src/github-copilot/openai-compatible-error.ts
+import { z } from "zod/v4";
+var openaiCompatibleErrorDataSchema = z.object({
+  error: z.object({
+    message: z.string(),
+    type: z.string().nullish(),
+    param: z.any().nullish(),
+    code: z.union([z.string(), z.number()]).nullish()
+  })
+});
+var defaultOpenAICompatibleErrorStructure = {
+  errorSchema: openaiCompatibleErrorDataSchema,
+  errorToMessage: (data) => data.error.message
+};
+
+export { openaiCompatibleErrorDataSchema, defaultOpenAICompatibleErrorStructure };

package/dist/chunks/location-mutation-1xksxgzs.js

@@ -0,0 +1,24 @@
+import {
+  exports_app
+} from "./location-mutation-50jxp3hw.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/session/model-headers.ts
+var exports_model_headers = {};
+__export(exports_model_headers, {
+  make: () => make,
+  SessionModelHeaders: () => exports_model_headers
+});
+var make = (session, app) => ({
+  "x-session-affinity": session.id,
+  "X-Session-Id": session.id,
+  ...session.parentID ? { "x-parent-session-id": session.parentID } : {},
+  "User-Agent": exports_app.useragent(app),
+  "x-opencode-project": session.projectID,
+  "x-opencode-session": session.id,
+  "x-opencode-client": app.name
+});
+
+export { make, exports_model_headers };

package/dist/chunks/location-mutation-25pxtba7.js

@@ -0,0 +1,13 @@
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/session/message.ts
+var exports_message = {};
+__export(exports_message, {
+  SessionMessage: () => exports_message
+});
+
+export * from "@opencode-ai/schema/session-message";
+
+export { exports_message };

package/dist/chunks/location-mutation-272jbdre.js

@@ -0,0 +1,47 @@
+import {
+  exports_wellknown
+} from "./location-mutation-ghhyjnwz.js";
+import {
+  exports_bus
+} from "./location-mutation-zz41wrms.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/wellknown/plugin.ts
+var exports_plugin = {};
+__export(exports_plugin, {
+  WellKnownPlugin: () => exports_plugin,
+  Plugin: () => Plugin
+});
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Effect, Stream } from "effect";
+var Plugin = define({
+  id: "opencode.wellknown",
+  effect: Effect.fn(function* (ctx) {
+    const bus = yield* exports_bus.Service;
+    const wellknown = yield* exports_wellknown.Service;
+    yield* wellknown.entries().pipe(Effect.orDie);
+    yield* ctx.integration.transform((draft) => {
+      wellknown.snapshot().forEach((entry) => {
+        if (!entry.manifest.auth)
+          return;
+        draft.update(entry.integrationID, (integration) => {
+          integration.name = new URL(entry.origin).hostname;
+        });
+        draft.method.update({
+          integrationID: entry.integrationID,
+          method: {
+            id: "login",
+            type: "command",
+            label: "Log in",
+            command: [...entry.manifest.auth.command]
+          }
+        });
+      });
+    });
+    yield* bus.subscribe(exports_wellknown.Event.Updated).pipe(Stream.runForEach(() => ctx.integration.reload()), Effect.forkScoped({ startImmediately: true }));
+  })
+});
+
+export { Plugin, exports_plugin };

package/dist/chunks/location-mutation-2e8rafee.js

@@ -0,0 +1,115 @@
+import {
+  configuredSettings
+} from "./location-mutation-e8rk8tex.js";
+import {
+  iife
+} from "./location-mutation-ehj9csmv.js";
+import {
+  exports_app
+} from "./location-mutation-50jxp3hw.js";
+import {
+  exports_provider
+} from "./location-mutation-d6vvk673.js";
+import {
+  __require
+} from "./location-mutation-rvfvac9x.js";
+
+// src/plugin/provider/cloudflare-workers-ai.ts
+import os from "os";
+import { Effect } from "effect";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Form } from "@opencode-ai/schema/form";
+var providerID = exports_provider.ID.make("cloudflare-workers-ai");
+var CloudflareWorkersAIPlugin = define({
+  id: "opencode.provider.cloudflare-workers-ai",
+  effect: Effect.fn(function* (ctx) {
+    const configured = yield* configuredSettings(providerID);
+    const form = iife(() => {
+      if (typeof configured?.baseURL === "string" || resolveAccountId(configured ?? {}))
+        return;
+      return Form.Fields.make([
+        {
+          type: "string",
+          key: "accountId",
+          title: "Enter your Cloudflare Account ID",
+          placeholder: "e.g. 1234567890abcdef1234567890abcdef",
+          required: true
+        }
+      ]);
+    });
+    yield* ctx.integration.transform((draft) => {
+      draft.method.update({
+        integrationID: providerID,
+        method: {
+          type: "key",
+          label: "API key",
+          form
+        }
+      });
+    });
+    yield* ctx.catalog.transform((evt) => {
+      const item = evt.provider.get(providerID);
+      if (!item)
+        return;
+      evt.provider.update(item.provider.id, (provider) => {
+        if (!exports_provider.isAISDK(provider.package))
+          return;
+        if (typeof provider.settings?.baseURL === "string")
+          return;
+        const accountId = resolveAccountId(provider.settings ?? {});
+        if (accountId)
+          provider.settings = { ...provider.settings, baseURL: workersEndpoint(accountId) };
+      });
+    });
+    yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+      if (evt.model.providerID !== providerID)
+        return;
+      if (evt.package !== "@ai-sdk/openai-compatible")
+        return;
+      const accountId = resolveAccountId(evt.options);
+      if (!hasWorkersEndpoint(evt.model) && !accountId)
+        return;
+      const mod = yield* Effect.promise(() => import("@ai-sdk/openai-compatible"));
+      evt.sdk = mod.createOpenAICompatible(sdkOptions({
+        ...evt.options,
+        baseURL: evt.options.baseURL ?? (accountId ? workersEndpoint(accountId) : undefined)
+      }, ctx.app));
+    }));
+    yield* ctx.aisdk.hook("language", Effect.fn(function* (evt) {
+      if (evt.model.providerID !== providerID)
+        return;
+      evt.language = evt.sdk.languageModel(evt.model.modelID ?? evt.model.id);
+    }));
+  })
+});
+function resolveAccountId(options) {
+  return process.env.CLOUDFLARE_ACCOUNT_ID ?? stringOption(options, "accountId");
+}
+function workersEndpoint(accountId) {
+  return `https://api.cloudflare.com/client/v4/accounts/${accountId}/ai/v1`;
+}
+function hasWorkersEndpoint(model) {
+  return exports_provider.isAISDK(model.package) && typeof model.settings?.baseURL === "string";
+}
+function sdkOptions(options, app) {
+  return {
+    ...options,
+    baseURL: expandAccountId(options.baseURL),
+    apiKey: process.env.CLOUDFLARE_API_KEY ?? options.apiKey,
+    headers: {
+      "User-Agent": `${exports_app.useragent(app)} cloudflare-workers-ai (${os.platform()} ${os.release()}; ${os.arch()})`,
+      ...options.headers
+    },
+    name: providerID
+  };
+}
+function expandAccountId(baseURL) {
+  if (typeof baseURL !== "string")
+    return baseURL;
+  return baseURL.replaceAll("${CLOUDFLARE_ACCOUNT_ID}", process.env.CLOUDFLARE_ACCOUNT_ID ?? "${CLOUDFLARE_ACCOUNT_ID}");
+}
+function stringOption(options, key) {
+  return typeof options[key] === "string" ? options[key] : undefined;
+}
+
+export { CloudflareWorkersAIPlugin };

package/dist/chunks/location-mutation-2hwtcyyk.js

@@ -0,0 +1,70 @@
+import {
+  PermissionTable
+} from "./location-mutation-nesb2rcz.js";
+import {
+  exports_project
+} from "./location-mutation-sbx2darh.js";
+import {
+  exports_database
+} from "./location-mutation-j0ksmf2f.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/permission/saved.ts
+var exports_saved = {};
+__export(exports_saved, {
+  node: () => node,
+  Service: () => Service,
+  PermissionSaved: () => exports_saved,
+  ListInput: () => ListInput,
+  Info: () => Info,
+  ID: () => ID,
+  AddInput: () => AddInput
+});
+import { eq } from "drizzle-orm";
+import { Context, Effect, Layer, Schema } from "effect";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+import { PermissionSaved } from "@opencode-ai/schema/permission-saved";
+var ID = PermissionSaved.ID;
+var Info = PermissionSaved.Info;
+var ListInput = Schema.Struct({
+  projectID: exports_project.ID.pipe(Schema.optional)
+}).annotate({ identifier: "PermissionSaved.ListInput" });
+var AddInput = Schema.Struct({
+  projectID: exports_project.ID,
+  action: Schema.String,
+  resources: Schema.Array(Schema.String)
+}).annotate({ identifier: "PermissionSaved.AddInput" });
+
+class Service extends Context.Service()("@opencode/PermissionSaved") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const { db } = yield* exports_database.Service;
+  const list = Effect.fn("PermissionSaved.list")(function* (input) {
+    const rows = yield* db.select().from(PermissionTable).where(input?.projectID ? eq(PermissionTable.project_id, input.projectID) : undefined).all().pipe(Effect.orDie);
+    return rows.map((row) => ({
+      id: row.id,
+      projectID: row.project_id,
+      action: row.action,
+      resource: row.resource
+    }));
+  });
+  const add = Effect.fn("PermissionSaved.add")(function* (input) {
+    if (!input.resources.length)
+      return;
+    yield* db.insert(PermissionTable).values(input.resources.map((resource) => ({
+      id: ID.create(),
+      project_id: input.projectID,
+      action: input.action,
+      resource
+    }))).onConflictDoNothing().run().pipe(Effect.orDie);
+  });
+  const remove = Effect.fn("PermissionSaved.remove")(function* (id) {
+    yield* db.delete(PermissionTable).where(eq(PermissionTable.id, id)).run().pipe(Effect.orDie);
+  });
+  return Service.of({ list, add, remove });
+}));
+var node = makeGlobalNode({ service: Service, layer, deps: [exports_database.node] });
+
+export { ID, Info, ListInput, AddInput, Service, node, exports_saved };