@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-wtztk69x.js

@@ -0,0 +1,24 @@
+// src/database/migration/20260602002951_lowly_union_jack.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260602002951_lowly_union_jack",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`permission\` (
+          \`id\` text PRIMARY KEY,
+          \`project_id\` text NOT NULL,
+          \`action\` text NOT NULL,
+          \`resource\` text NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          CONSTRAINT \`fk_permission_project_id_project_id_fk\` FOREIGN KEY (\`project_id\`) REFERENCES \`project\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`CREATE UNIQUE INDEX \`permission_project_action_resource_idx\` ON \`permission\` (\`project_id\`,\`action\`,\`resource\`);`);
+    });
+  }
+};
+var _20260602002951_lowly_union_jack_default = migration;
+
+export { _20260602002951_lowly_union_jack_default };

package/dist/chunks/worktree-x0ckcb58.js

@@ -0,0 +1,54 @@
+// src/github-copilot/chat/openai-compatible-prepare-tools.ts
+import { UnsupportedFunctionalityError } from "@ai-sdk/provider";
+function prepareTools2({
+  tools,
+  toolChoice
+}) {
+  tools = tools?.length ? tools : undefined;
+  const toolWarnings = [];
+  if (tools == null) {
+    return { tools: undefined, toolChoice: undefined, toolWarnings };
+  }
+  const openaiCompatTools = [];
+  for (const tool of tools) {
+    if (tool.type === "provider") {
+      toolWarnings.push({ type: "unsupported", feature: `tool type: ${tool.type}` });
+    } else {
+      openaiCompatTools.push({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.inputSchema
+        }
+      });
+    }
+  }
+  if (toolChoice == null) {
+    return { tools: openaiCompatTools, toolChoice: undefined, toolWarnings };
+  }
+  const type = toolChoice.type;
+  switch (type) {
+    case "auto":
+    case "none":
+    case "required":
+      return { tools: openaiCompatTools, toolChoice: type, toolWarnings };
+    case "tool":
+      return {
+        tools: openaiCompatTools,
+        toolChoice: {
+          type: "function",
+          function: { name: toolChoice.toolName }
+        },
+        toolWarnings
+      };
+    default: {
+      const _exhaustiveCheck = type;
+      throw new UnsupportedFunctionalityError({
+        functionality: `tool choice type: ${_exhaustiveCheck}`
+      });
+    }
+  }
+}
+
+export { prepareTools2 };

package/dist/chunks/worktree-x1ezjp6w.js

@@ -0,0 +1,39 @@
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/session/subagent-completion.ts
+var exports_subagent_completion = {};
+__export(exports_subagent_completion, {
+  NO_TEXT: () => NO_TEXT2,
+  SubagentCompletion: () => exports_subagent_completion,
+  deliver: () => deliver2,
+  text: () => text2
+});
+import { Effect } from "effect";
+var NO_TEXT2 = "Subagent completed without a text response.";
+function text2(message) {
+  if (message?.type !== "assistant")
+    return NO_TEXT2;
+  return message.content.filter((part) => part.type === "text").map((part) => part.text).join("") || NO_TEXT2;
+}
+var deliver2 = Effect.fnUntraced(function* (sessions, jobs, input) {
+  if (input.status === "running")
+    return;
+  const recovery = input.recovery;
+  const text = input.status === "completed" ? input.output ?? NO_TEXT2 : input.status === "error" ? input.error ?? "Subagent failed" : "Subagent cancelled";
+  yield* sessions.synthetic({
+    ...input.notificationID ? { id: input.notificationID } : {},
+    sessionID: recovery.parentSessionID,
+    ...input.resume === false ? { resume: false } : {},
+    description: recovery.description,
+    text: `<subagent sessionID="${recovery.childSessionID}" state="${input.status}" description="${recovery.description}">
+${text}
+</subagent>`,
+    metadata: { source: "subagent", childID: recovery.childSessionID, agent: recovery.agent, state: input.status }
+  });
+  if (input.notificationID)
+    yield* jobs.completeBackground(input.notificationID);
+});
+
+export { NO_TEXT2, text2, deliver2, exports_subagent_completion };

package/dist/chunks/worktree-x1xcpfha.js

@@ -0,0 +1,130 @@
+import {
+  Key4,
+  removed2,
+  make21,
+  diffByKey2
+} from "./worktree-eaj1djv9.js";
+import {
+  Summary2,
+  summarize2,
+  namespaceLine2
+} from "./worktree-3fc6dm20.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/codemode/instructions.ts
+var exports_instructions3 = {};
+__export(exports_instructions3, {
+  CodeModeInstructions: () => exports_instructions3,
+  make: () => make13,
+  render: () => render2,
+  update: () => update3
+});
+import { searchSignature, toolExpression } from "@opencode/codemode";
+import { Effect, Schema } from "effect";
+var prompt = (hasMoreTools) => `The Code Mode tool catalog below is ${hasMoreTools ? "partial" : "complete"}.
+
+${hasMoreTools ? "The Code Mode catalog and `search` results are" : "This catalog is"} the complete set of tools callable inside \`execute\`. It does not affect tools exposed directly outside Code Mode.${hasMoreTools ? `
+
+## Search
+
+Call \`search(...)\` to discover exact paths and signatures for additional tools:
+
+- ${searchSignature}` : ""}
+
+## Available tools`;
+function render2(catalog) {
+  if (catalog.total === 0)
+    return "No Code Mode tools are currently available. Later Code Mode catalog updates may add or remove tools. Do not call `execute` unless there is at least one available Code Mode tool.";
+  const tools = catalog.namespaces.flatMap((namespace) => {
+    return [namespaceLine2(namespace), ...namespace.entries.map((entry) => entry.line)];
+  });
+  return `${prompt(catalog.shown < catalog.total)}
+
+${tools.join(`
+`)}`;
+}
+function update3(previous, current) {
+  const replacement = `The Code Mode tool catalog has changed. This catalog supersedes the previous Code Mode tool catalog.
+
+${render2(current)}`;
+  if (current.total === 0)
+    return replacement;
+  const previousComplete = previous.shown === previous.total;
+  const currentComplete = current.shown === current.total;
+  if (previousComplete !== currentComplete)
+    return replacement;
+  const descriptions = diffByKey2(previous.namespaces.filter((namespace) => namespace.description !== undefined), current.namespaces.filter((namespace) => namespace.description !== undefined), (namespace) => namespace.name, (before, after) => before.description !== after.description);
+  if (descriptions.added.length > 0 || descriptions.removed.length > 0 || descriptions.changed.length > 0)
+    return replacement;
+  const diff = diffByKey2(previous.namespaces.flatMap((namespace) => namespace.entries), current.namespaces.flatMap((namespace) => namespace.entries), (entry) => entry.path, (before, after) => before.line !== after.line);
+  const entriesChanged = diff.added.length > 0 || diff.removed.length > 0 || diff.changed.length > 0;
+  if (!currentComplete) {
+    if (entriesChanged)
+      return replacement;
+    const namespaces = diffByKey2(previous.namespaces, current.namespaces, (namespace) => namespace.name, (before, after) => before.count !== after.count);
+    const changed = namespaces.added.length > 0 || namespaces.removed.length > 0 || namespaces.changed.length > 0;
+    if (!changed)
+      return replacement;
+    const parts = ["The Code Mode tool catalog has changed."];
+    if (namespaces.added.length > 0) {
+      parts.push(`New tool namespaces are available: ${namespaces.added.map((namespace) => `\`${namespace.name}\` (${namespace.count} tools)`).join(", ")}.`);
+    }
+    if (namespaces.changed.length > 0) {
+      parts.push(`The following namespace inventories changed; search them again before relying on previous results: ${namespaces.changed.map((change) => `\`${change.current.name}\` now has ${change.current.count} tools`).join(", ")}.`);
+    }
+    if (namespaces.removed.length > 0) {
+      parts.push(`The following tool namespaces are no longer available and must not be used: ${namespaces.removed.map((namespace) => `\`${namespace.name}\``).join(", ")}.`);
+    }
+    const delta = parts.join(`
+
+`);
+    if (delta.length < replacement.length)
+      return delta;
+    return replacement;
+  }
+  if (!entriesChanged)
+    return replacement;
+  const parts = ["The Code Mode tool catalog has changed."];
+  if (diff.added.length > 0) {
+    parts.push([
+      "New tools are available in addition to those previously listed:",
+      ...diff.added.map((entry) => entry.line)
+    ].join(`
+`));
+  }
+  if (diff.changed.length > 0) {
+    parts.push([
+      "Changed tool listings supersede the previously listed ones:",
+      ...diff.changed.map((change) => change.current.line)
+    ].join(`
+`));
+  }
+  if (diff.removed.length > 0) {
+    parts.push(`The following tools are no longer available and must not be called: ${diff.removed.map((entry) => toolExpression(entry.path)).join(", ")}.`);
+  }
+  const delta = parts.join(`
+
+`);
+  if (delta.length < replacement.length)
+    return delta;
+  return replacement;
+}
+var key = Key4.make("core/codemode");
+var codec = Schema.toCodecJson(Summary2);
+var make13 = (inventory) => {
+  const catalog = inventory === undefined ? removed2 : summarize2(inventory);
+  return make21({
+    key,
+    codec,
+    read: Effect.succeed(catalog),
+    render: {
+      initial: render2,
+      changed: update3,
+      removed: () => "Code Mode tools are no longer available. Do not use any previously listed Code Mode tools."
+    }
+  });
+};
+
+export { render2, update3, make13, exports_instructions3 };

package/dist/chunks/worktree-x43y2vfs.js

@@ -0,0 +1,263 @@
+import {
+  definition2,
+  normalizedName2
+} from "./worktree-3w5fmr99.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/codemode/tool.ts
+var exports_tool2 = {};
+__export(exports_tool2, {
+  CodeModeTool: () => exports_tool2,
+  catalog: () => catalog2,
+  create: () => create2
+});
+import { CodeMode, Namespace, Tool, toolError } from "@opencode/codemode";
+import { Effect, Ref, Schema, Semaphore } from "effect";
+var ExecuteFile = Schema.Struct({
+  data: Schema.String,
+  mime: Schema.String,
+  name: Schema.optionalKey(Schema.String)
+});
+var ExecuteCall = Schema.Struct({
+  tool: Schema.String,
+  status: Schema.Literals(["running", "completed", "error"]),
+  input: Schema.optionalKey(Schema.Record(Schema.String, Schema.Json))
+});
+var ExecuteOutput = Schema.Struct({
+  output: Schema.String,
+  toolCalls: Schema.Array(ExecuteCall),
+  error: Schema.optionalKey(Schema.Literal(true)),
+  files: Schema.Array(ExecuteFile)
+});
+var description = [
+  "Run JavaScript in a confined Code Mode runtime to orchestrate tool calls and compose their results.",
+  "Imports, direct filesystem access, and timers are unavailable. Do not use `fetch`; all external access goes through `tools`.",
+  "Within `{ code }`, the only callable tools are those explicitly listed in the Code Mode catalog instructions or returned by the `search` function. Inside `{ code }`, ignore tools shown outside the Code Mode catalog. They are not available in the Code Mode runtime.",
+  'Call tools through `tools` using only exact paths and signatures from the catalog. Do not infer or normalize tool names; preserve bracket notation such as `tools.<namespace>["tool-name"](input)`.',
+  "Prefer an explicit `return`; if omitted, the final top-level expression becomes the result.",
+  "Await every call whose completion matters; pending calls are interrupted when execution ends. Run independent calls concurrently with `Promise.all`."
+].join(`
+`);
+var create2 = (inventory, executeTool) => {
+  return {
+    name: "execute",
+    description,
+    input: CodeMode.Input,
+    output: ExecuteOutput,
+    execute: ({ code }, context) => Effect.gen(function* () {
+      const callIndex = yield* Ref.make(0);
+      const files = yield* Ref.make([]);
+      const calls = yield* Ref.make([]);
+      const lock = Semaphore.makeUnsafe(1);
+      const updateCalls = (update) => lock.withPermit(Ref.updateAndGet(calls, update).pipe(Effect.flatMap((toolCalls) => context.progress({ toolCalls }))));
+      const result = yield* runtime(inventory, (name, tool, input) => Effect.gen(function* () {
+        const index = yield* Ref.getAndUpdate(callIndex, (index) => index + 1);
+        const executed = yield* executeTool(name, tool, input, context);
+        const content = typeof executed.content === "string" ? [{ type: "text", text: executed.content }] : executed.content ?? [];
+        const outputFileParts = outputFiles(content);
+        if (outputFileParts.length > 0)
+          yield* Ref.update(files, (items) => [...items, { index, files: outputFileParts }]);
+        if (executed.output !== undefined)
+          return executed.output;
+        const text = content.flatMap((part) => part.type === "text" ? [part.text] : []).join(`
+`);
+        return text === "" ? null : text;
+      }), {
+        onToolCallStart: ({ index, name, input }) => {
+          const shown = displayInput(input);
+          return updateCalls((items) => {
+            const next = [...items];
+            next[index] = { tool: name, status: "running", ...shown ? { input: shown } : {} };
+            return next;
+          });
+        },
+        onToolCallEnd: ({ index, name, input, outcome }) => {
+          const shown = displayInput(input);
+          return updateCalls((items) => {
+            const next = [...items];
+            next[index] = {
+              ...items[index] ?? { tool: name, ...shown ? { input: shown } : {} },
+              status: outcome === "success" ? "completed" : "error"
+            };
+            return next;
+          });
+        }
+      }).execute(code);
+      const toolCalls = yield* Ref.get(calls);
+      const collected = (yield* Ref.get(files)).toSorted((left, right) => left.index - right.index).flatMap((item) => item.files);
+      const output = formatResult(result);
+      const value = {
+        output,
+        toolCalls,
+        files: collected,
+        ...result.ok ? {} : { error: true }
+      };
+      const content = [
+        { type: "text", text: value.output },
+        ...value.files.map((file) => ({
+          type: "file",
+          uri: `data:${file.mime};base64,${file.data}`,
+          mime: file.mime,
+          ...file.name === undefined ? {} : { name: file.name }
+        }))
+      ];
+      const metadata = {
+        toolCalls: value.toolCalls,
+        ...value.error ? { error: true } : {}
+      };
+      return {
+        output: value,
+        content,
+        metadata
+      };
+    })
+  };
+};
+var catalog2 = (inventory) => {
+  const pinned = new Set(Array.from(inventory.tools.values()).filter((registration) => registration.options?.pinned === true).map(qualifiedName));
+  const root = { children: new Map };
+  for (const namespace of inventory.namespaces?.values() ?? [])
+    getNode(root, namespace.name).namespace = namespace;
+  for (const tool of runtime(inventory, () => Effect.fail(toolError("Execute context is unavailable"))).catalog())
+    getNode(root, tool.path).tool = {
+      type: "tool",
+      name: tool.path.split(".").at(-1) ?? tool.path,
+      description: tool.description,
+      signature: tool.signature,
+      pinned: pinned.has(tool.path)
+    };
+  return {
+    tools: renderCatalog(root)
+  };
+};
+function renderCatalog(root) {
+  return Array.from(root.children).toSorted(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).flatMap(([name, node]) => {
+    const tools = renderCatalog(node);
+    const namespace = node.namespace === undefined && tools.length === 0 ? undefined : {
+      type: "namespace",
+      name,
+      ...node.namespace?.description === undefined ? {} : { description: node.namespace.description },
+      tools
+    };
+    if (node.tool === undefined)
+      return namespace === undefined ? [] : [namespace];
+    if (namespace === undefined)
+      return [node.tool];
+    return [node.tool, namespace];
+  });
+}
+function runtime(inventory, executeTool, hooks) {
+  const root = { children: new Map };
+  for (const namespace of inventory.namespaces?.values() ?? [])
+    getNode(root, namespace.name).namespace = namespace;
+  for (const [name, registration] of inventory.tools) {
+    const child = definition2(registration);
+    getNode(root, qualifiedName(registration)).tool = Tool.make({
+      description: child.description,
+      input: child.inputSchema,
+      output: child.outputSchema ?? Schema.NullOr(Schema.String),
+      execute: (input) => executeTool(name, registration, input)
+    });
+  }
+  const tools = renderTools(root);
+  return CodeMode.make({ tools, ...hooks });
+}
+function getNode(root, path) {
+  return path.split(".").reduce((parent, name) => {
+    const child = parent.children.get(name) ?? { children: new Map };
+    parent.children.set(name, child);
+    return child;
+  }, root);
+}
+function renderTools(root) {
+  const callables = new Map;
+  const tools = renderChildren(root, [], callables);
+  for (const [path, tool] of callables)
+    tools[path] = tool;
+  return tools;
+}
+function renderChildren(node, path, callables) {
+  return Object.fromEntries(Array.from(node.children).flatMap(([name, child]) => {
+    const next = [...path, name];
+    if (path.length === 0 && child.tool !== undefined && (child.namespace !== undefined || child.children.size > 0)) {
+      const tools = {};
+      flattenTools(child, next, tools);
+      return Object.entries(tools);
+    }
+    return [[name, renderEntry(child, next, callables)]];
+  }));
+}
+function renderEntry(node, path, callables) {
+  const tools = renderChildren(node, path, callables);
+  if (node.tool !== undefined && (node.namespace !== undefined || node.children.size > 0))
+    callables.set(path.join("."), node.tool);
+  if (node.namespace !== undefined)
+    return Namespace.make({
+      description: node.namespace.description,
+      tools
+    });
+  if (node.tool === undefined)
+    return tools;
+  if (node.children.size === 0)
+    return node.tool;
+  return tools;
+}
+function flattenTools(node, path, tools) {
+  if (node.tool !== undefined)
+    tools[path.join(".")] = node.tool;
+  for (const [name, child] of node.children)
+    flattenTools(child, [...path, name], tools);
+}
+function qualifiedName(registration) {
+  const normalized = normalizedName2(registration);
+  if (registration.options?.namespace === undefined)
+    return normalized;
+  return `${registration.options.namespace}.${normalized}`;
+}
+function displayInput(input) {
+  if (input === null || input === undefined)
+    return;
+  if (typeof input !== "object" || Array.isArray(input))
+    return { input };
+  if (Object.keys(input).length === 0)
+    return;
+  return input;
+}
+function formatResult(result) {
+  const output = result.ok ? formatValue(result.value) : [result.error.message, ...(result.error.suggestions ?? []).filter((hint) => !result.error.message.includes(hint))].join(`
+`).trim();
+  const warnings = result.ok && result.warnings && result.warnings.length > 0 ? `Warnings:
+${result.warnings.map((item) => `- [${item.kind}] ${item.message}`).join(`
+`)}` : undefined;
+  const logs = result.logs && result.logs.length > 0 ? `Logs:
+${result.logs.join(`
+`)}` : undefined;
+  return [output, warnings, logs].filter((part) => part !== undefined && part !== "").join(`
+
+`);
+}
+function formatValue(value) {
+  if (typeof value === "string")
+    return value;
+  return JSON.stringify(value, null, 2) ?? String(value);
+}
+function outputFiles(content) {
+  return content.flatMap((part) => {
+    if (part.type !== "file")
+      return [];
+    const prefix = `data:${part.mime};base64,`;
+    if (!part.uri.startsWith(prefix))
+      return [];
+    return [
+      {
+        data: part.uri.slice(prefix.length),
+        mime: part.mime,
+        ...part.name === undefined ? {} : { name: part.name }
+      }
+    ];
+  });
+}
+
+export { create2, catalog2, exports_tool2 };

package/dist/chunks/worktree-x61499pn.js

@@ -0,0 +1,18 @@
+// src/github-copilot/chat/map-openai-compatible-finish-reason.ts
+function mapOpenAICompatibleFinishReason2(finishReason) {
+  switch (finishReason) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "content_filter":
+      return "content-filter";
+    case "function_call":
+    case "tool_calls":
+      return "tool-calls";
+    default:
+      return "other";
+  }
+}
+
+export { mapOpenAICompatibleFinishReason2 };

package/dist/chunks/worktree-xmc8nah8.js

@@ -0,0 +1,69 @@
+import {
+  Service80,
+  node85
+} from "./worktree-ecj1wrg9.js";
+import {
+  PermissionTable2
+} from "./worktree-hdnk95c8.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/permission/saved.ts
+var exports_saved = {};
+__export(exports_saved, {
+  AddInput: () => AddInput2,
+  ID: () => ID14,
+  Info: () => Info27,
+  ListInput: () => ListInput4,
+  PermissionSaved: () => exports_saved,
+  Service: () => Service71,
+  node: () => node76
+});
+import { eq } from "drizzle-orm";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Project } from "@opencode/schema/project";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+import { PermissionSaved } from "@opencode/schema/permission-saved";
+var ID14 = PermissionSaved.ID;
+var Info27 = PermissionSaved.Info;
+var ListInput4 = Schema.Struct({
+  projectID: Project.ID.pipe(Schema.optional)
+}).annotate({ identifier: "PermissionSaved.ListInput" });
+var AddInput2 = Schema.Struct({
+  projectID: Project.ID,
+  action: Schema.String,
+  resources: Schema.Array(Schema.String)
+}).annotate({ identifier: "PermissionSaved.AddInput" });
+
+class Service71 extends Context.Service()("@opencode/PermissionSaved") {
+}
+var layer = Layer.effect(Service71, Effect.gen(function* () {
+  const db = (yield* Service80).db;
+  const list = Effect.fnUntraced(function* (input) {
+    const rows = yield* db.select().from(PermissionTable2).where(input?.projectID ? eq(PermissionTable2.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(PermissionTable2).values(input.resources.map((resource) => ({
+      id: ID14.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(PermissionTable2).where(eq(PermissionTable2.id, id)).run().pipe(Effect.orDie);
+  });
+  return Service71.of({ list, add, remove });
+}));
+var node76 = makeGlobalNode({ service: Service71, layer, deps: [node85] });
+
+export { ID14, Info27, ListInput4, AddInput2, Service71, node76, exports_saved };

package/dist/chunks/worktree-xrd4famk.js

@@ -0,0 +1,35 @@
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/app.ts
+var exports_app = {};
+__export(exports_app, {
+  App: () => exports_app,
+  Metadata: () => Metadata2,
+  configured: () => configured10,
+  layer: () => layer21,
+  make: () => make19,
+  node: () => node63,
+  useragent: () => useragent2
+});
+import { Context, Layer } from "effect";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+var Metadata2 = Context.Reference("@opencode/App", {
+  defaultValue: () => make19()
+});
+function make19(input = {}) {
+  return {
+    name: input.name ?? "opencode",
+    version: input.version ?? "unknown",
+    channel: input.channel ?? "unknown"
+  };
+}
+function useragent2(app) {
+  return `opencode/${app.channel}/${app.version}/${app.name}`;
+}
+var layer21 = (input) => Layer.succeed(Metadata2, make19(input));
+var configured10 = (input) => makeGlobalNode({ service: Metadata2, layer: layer21(input), deps: [] });
+var node63 = configured10();
+
+export { Metadata2, make19, useragent2, layer21, configured10, node63, exports_app };