@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-ead3g9p8.js

@@ -0,0 +1,69 @@
+import {
+  PositiveInt2
+} from "./worktree-922hggd3.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/v1/config/mcp.ts
+var exports_mcp5 = {};
+__export(exports_mcp5, {
+  ConfigMCPV1: () => exports_mcp5,
+  Info: () => Info20,
+  Local: () => Local2,
+  OAuth: () => OAuth2,
+  Remote: () => Remote2
+});
+import { Schema } from "effect";
+var Local2 = Schema.Struct({
+  type: Schema.Literal("local").annotate({ description: "Type of MCP server connection" }),
+  command: Schema.mutable(Schema.Array(Schema.String)).annotate({
+    description: "Command and arguments to run the MCP server"
+  }),
+  cwd: Schema.optional(Schema.String).annotate({
+    description: "Working directory for the MCP server process. Relative paths resolve from the workspace directory."
+  }),
+  environment: Schema.optional(Schema.Record(Schema.String, Schema.String)).annotate({
+    description: "Environment variables to set when running the MCP server"
+  }),
+  enabled: Schema.optional(Schema.Boolean).annotate({
+    description: "Enable or disable the MCP server on startup"
+  }),
+  timeout: Schema.optional(PositiveInt2).annotate({
+    description: "Timeout in ms for MCP server requests. Defaults to 5000 (5 seconds) if not specified."
+  })
+}).annotate({ identifier: "McpLocalConfig" });
+var OAuth2 = Schema.Struct({
+  clientId: Schema.optional(Schema.String).annotate({
+    description: "OAuth client ID. If not provided, dynamic client registration (RFC 7591) will be attempted."
+  }),
+  clientSecret: Schema.optional(Schema.String).annotate({
+    description: "OAuth client secret (if required by the authorization server)"
+  }),
+  scope: Schema.optional(Schema.String).annotate({ description: "OAuth scopes to request during authorization" }),
+  callbackPort: Schema.optional(Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 65535 }))).annotate({
+    description: "Port for the local OAuth callback server (default: 19876). Shorthand for redirectUri when only the port needs changing. Ignored if redirectUri is set."
+  }),
+  redirectUri: Schema.optional(Schema.String).annotate({
+    description: "OAuth redirect URI (default: http://127.0.0.1:19876/mcp/oauth/callback)."
+  })
+}).annotate({ identifier: "McpOAuthConfig" });
+var Remote2 = Schema.Struct({
+  type: Schema.Literal("remote").annotate({ description: "Type of MCP server connection" }),
+  url: Schema.String.annotate({ description: "URL of the remote MCP server" }),
+  enabled: Schema.optional(Schema.Boolean).annotate({
+    description: "Enable or disable the MCP server on startup"
+  }),
+  headers: Schema.optional(Schema.Record(Schema.String, Schema.String)).annotate({
+    description: "Headers to send with the request"
+  }),
+  oauth: Schema.optional(Schema.Union([OAuth2, Schema.Literal(false)])).annotate({
+    description: "OAuth authentication configuration for the MCP server. Set to false to disable OAuth auto-detection."
+  }),
+  timeout: Schema.optional(PositiveInt2).annotate({
+    description: "Timeout in ms for MCP server requests. Defaults to 5000 (5 seconds) if not specified."
+  })
+}).annotate({ identifier: "McpRemoteConfig" });
+var Info20 = Schema.Union([Local2, Remote2]).annotate({ discriminator: "type" });
+
+export { Local2, OAuth2, Remote2, Info20, exports_mcp5 };

package/dist/chunks/worktree-eaj1djv9.js

@@ -0,0 +1,196 @@
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/instructions/index.ts
+var exports_instructions6 = {};
+__export(exports_instructions6, {
+  Delta: () => Delta2,
+  DuplicateKeyError: () => DuplicateKeyError2,
+  Hash: () => Hash2,
+  InitializationBlocked: () => InitializationBlocked2,
+  Instructions: () => exports_instructions6,
+  Key: () => Key4,
+  Values: () => Values2,
+  applyHashDelta: () => applyHashDelta2,
+  combine: () => combine2,
+  diff: () => diff2,
+  diffByKey: () => diffByKey2,
+  empty: () => empty3,
+  hash: () => hash2,
+  make: () => make21,
+  read: () => read3,
+  removed: () => removed2,
+  renderInitial: () => renderInitial2,
+  renderUpdate: () => renderUpdate2,
+  unavailable: () => unavailable3
+});
+import { createHash } from "crypto";
+import { Instruction } from "@opencode/schema/instruction";
+import { Data, Effect, Option, Schema } from "effect";
+var Key4 = Instruction.Key;
+var Hash2 = Instruction.Hash;
+var Values2 = Instruction.Values;
+var Delta2 = Instruction.Delta;
+var NonValue = Data.taggedEnum();
+var unavailable3 = NonValue.Unavailable();
+var removed2 = NonValue.Removed();
+
+class InitializationBlocked2 extends Schema.TaggedError()("Instructions.InitializationBlocked", { keys: Schema.Array(Key4) }) {
+  get message() {
+    return `Instruction initialization blocked by unavailable sources: ${this.keys.join(", ")}`;
+  }
+}
+
+class DuplicateKeyError2 extends Schema.TaggedError()("Instructions.DuplicateKeyError", {
+  key: Key4
+}) {
+  get message() {
+    return `Duplicate instruction key: ${this.key}`;
+  }
+}
+var empty3 = [];
+function make21(source) {
+  const decode = Schema.decodeUnknownOption(source.codec);
+  const encode = Schema.encodeSync(source.codec);
+  const initial = (value) => requireText(source.key, "initial", source.render.initial(value));
+  const decodeValue = (value) => Option.getOrUndefined(decode(value));
+  return [
+    {
+      key: source.key,
+      read: source.read.pipe(Effect.map((value) => {
+        if (isUnavailable(value))
+          return unavailable3;
+        if (isRemoved(value))
+          return removed2;
+        return encode(value);
+      })),
+      initial: (value) => {
+        const decoded = decodeValue(value);
+        return decoded === undefined ? undefined : initial(decoded);
+      },
+      changed: (previous, current) => {
+        const before = decodeValue(previous);
+        const after = decodeValue(current);
+        if (after === undefined)
+          return;
+        if (before === undefined)
+          return initial(after);
+        return requireText(source.key, "changed", source.render.changed(before, after));
+      },
+      removed: (previous) => {
+        const decoded = decodeValue(previous);
+        return decoded === undefined || source.render.removed === undefined ? undefined : requireText(source.key, "removed", source.render.removed(decoded));
+      }
+    }
+  ];
+}
+function combine2(values) {
+  const sources = values.flat();
+  const keys = new Set;
+  for (const source of sources) {
+    if (keys.has(source.key))
+      throw new DuplicateKeyError2({ key: source.key });
+    keys.add(source.key);
+  }
+  return sources;
+}
+function read3(value) {
+  return Effect.forEach(value, (source) => source.read.pipe(Effect.map((observed) => ({ key: source.key, value: observed }))), { concurrency: "unbounded" });
+}
+function diff2(observed, previous) {
+  const blocked = previous ? [] : observed.flatMap((entry) => isUnavailable(entry.value) ? [entry.key] : []);
+  if (blocked.length > 0)
+    return Effect.fail(new InitializationBlocked2({ keys: blocked }));
+  const delta = {};
+  const blobs = {};
+  for (const entry of observed) {
+    if (isUnavailable(entry.value))
+      continue;
+    if (isRemoved(entry.value)) {
+      if (previous && Object.hasOwn(previous, entry.key))
+        delta[entry.key] = Instruction.removed;
+      continue;
+    }
+    const next = hash2(entry.value);
+    if (previous?.[entry.key] === next)
+      continue;
+    delta[entry.key] = next;
+    blobs[next] = entry.value;
+  }
+  return Effect.succeed({ delta, blobs });
+}
+function renderInitial2(value, values) {
+  return render(value.flatMap((source) => {
+    if (!Object.hasOwn(values, source.key))
+      return [];
+    const text = source.initial(values[source.key]);
+    return text === undefined ? [] : [text];
+  }));
+}
+function renderUpdate2(value, previous, delta) {
+  return render(value.flatMap((source) => {
+    if (!Object.hasOwn(delta, source.key))
+      return [];
+    const current = delta[source.key];
+    if (Option.isNone(current)) {
+      if (!Object.hasOwn(previous, source.key))
+        return [];
+      const text = source.removed(previous[source.key]);
+      return text === undefined ? [] : [text];
+    }
+    const next = current.value;
+    const text = Object.hasOwn(previous, source.key) ? source.changed(previous[source.key], next) : source.initial(next);
+    return text === undefined ? [] : [text];
+  }));
+}
+function hash2(value) {
+  return Hash2.make(createHash("sha256").update(canonical(value)).digest("hex"));
+}
+function applyHashDelta2(values, delta) {
+  const result = { ...values };
+  for (const [key, value] of Object.entries(delta)) {
+    if (value === Instruction.removed)
+      delete result[key];
+    else
+      result[key] = value;
+  }
+  return result;
+}
+function diffByKey2(previous, current, key, changed) {
+  const currentKeys = new Set(current.map(key));
+  const previousByKey = new Map(previous.map((value) => [key(value), value]));
+  return {
+    added: current.filter((value) => !previousByKey.has(key(value))),
+    removed: previous.filter((value) => !currentKeys.has(key(value))),
+    changed: current.flatMap((value) => {
+      const before = previousByKey.get(key(value));
+      return before === undefined || !changed(before, value) ? [] : [{ previous: before, current: value }];
+    })
+  };
+}
+function render(parts) {
+  return parts.join(`
+
+`);
+}
+function isUnavailable(value) {
+  return value === unavailable3;
+}
+function isRemoved(value) {
+  return value === removed2;
+}
+function canonical(value) {
+  if (Array.isArray(value))
+    return `[${value.map(canonical).join(",")}]`;
+  if (value !== null && typeof value === "object")
+    return `{${Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, entry]) => `${JSON.stringify(key)}:${canonical(entry)}`).join(",")}}`;
+  return JSON.stringify(value);
+}
+function requireText(key, kind, text) {
+  if (text.length === 0)
+    throw new Error(`Instruction source ${key} rendered an empty ${kind}`);
+  return text;
+}
+
+export { Key4, Hash2, Values2, Delta2, unavailable3, removed2, InitializationBlocked2, DuplicateKeyError2, empty3, make21, combine2, read3, diff2, renderInitial2, renderUpdate2, hash2, applyHashDelta2, diffByKey2, exports_instructions6 };

package/dist/chunks/worktree-ec1grn59.js

@@ -0,0 +1,5 @@
+// src/session/event.ts
+export * from "@opencode/schema/session-event";
+import * as SessionEvent2 from "@opencode/schema/session-event";
+
+export { SessionEvent2 };

package/dist/chunks/worktree-ecj1wrg9.js

@@ -0,0 +1,82 @@
+import {
+  makeWithDefaults2
+} from "./worktree-jrra6jmc.js";
+import {
+  apply3
+} from "./worktree-a6ftqyym.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/database/database.ts
+var exports_database = {};
+__export(exports_database, {
+  Database: () => exports_database,
+  Options: () => Options11,
+  Service: () => Service80,
+  configured: () => configured13,
+  configuredClient: () => configuredClient2,
+  layer: () => layer26,
+  layerFromClient: () => layerFromClient2,
+  node: () => node85
+});
+import { sqliteLayer, supportsForeignKeyToggle, supportsTuningPragmas } from "#sqlite";
+import { Context, Effect, Layer, Schema, Semaphore } from "effect";
+import { Global } from "@opencode/util/global";
+import { isAbsolute, join } from "path";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+var makeDatabase = makeWithDefaults2();
+var Options11 = Schema.Struct({
+  path: Schema.optional(Schema.String)
+});
+
+class Service80 extends Context.Service()("@opencode/storage/Database") {
+}
+var databaseLayer = (lock) => Layer.effect(Service80, Effect.gen(function* () {
+  const db = yield* makeDatabase;
+  if (supportsTuningPragmas) {
+    yield* db.run("PRAGMA journal_mode = WAL");
+    yield* db.run("PRAGMA synchronous = NORMAL");
+    yield* db.run("PRAGMA busy_timeout = 5000");
+    yield* db.run("PRAGMA cache_size = -64000");
+    yield* db.run("PRAGMA wal_checkpoint(PASSIVE)");
+  }
+  if (supportsForeignKeyToggle)
+    yield* db.run("PRAGMA foreign_keys = ON");
+  const semaphore = yield* lock;
+  yield* semaphore.withPermit(apply3(db));
+  return { db };
+}).pipe(Effect.orDie));
+var locks = new Map;
+function lockFor(filename) {
+  const existing = locks.get(filename);
+  if (existing)
+    return existing;
+  const lock = Semaphore.makeUnsafe(1);
+  locks.set(filename, lock);
+  return lock;
+}
+function layer26(options = { path: ":memory:" }) {
+  return Layer.unwrap(Effect.gen(function* () {
+    const provide = (filename) => databaseLayer(filename === ":memory:" ? Semaphore.make(1) : Effect.succeed(lockFor(filename))).pipe(Layer.provide(sqliteLayer({ filename })));
+    const filename = options.path ?? ":memory:";
+    if (filename === ":memory:" || isAbsolute(filename))
+      return provide(filename);
+    const global = yield* Global.Service;
+    return provide(join(global.data, filename));
+  }));
+}
+var layerFromClient2 = databaseLayer(Semaphore.make(1));
+function configured13(options) {
+  return makeGlobalNode({ service: Service80, layer: layer26(options), deps: [Global.node] });
+}
+function configuredClient2(client) {
+  return makeGlobalNode({
+    service: Service80,
+    layer: layerFromClient2.pipe(Layer.provide(client)),
+    deps: [Global.node]
+  });
+}
+var node85 = configured13({ path: ":memory:" });
+
+export { Options11, Service80, layer26, layerFromClient2, configured13, configuredClient2, node85, exports_database };

package/dist/chunks/worktree-edbbhmy9.js

@@ -0,0 +1,36 @@
+import {
+  isAISDK2,
+  packageName2
+} from "./worktree-9qn3qky1.js";
+import {
+  ID11
+} from "./worktree-esam66tc.js";
+
+// src/plugin/provider/openrouter.ts
+import { Effect } from "effect";
+import { define } from "@opencode/plugin/effect/plugin";
+var OpenRouterPlugin2 = define({
+  id: "opencode.provider.openrouter",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.catalog.transform((evt) => {
+      for (const item of evt.provider.list()) {
+        if (!isAISDK2(item.provider.package))
+          continue;
+        if (packageName2(item.provider.package) !== "@openrouter/ai-sdk-provider")
+          continue;
+        evt.provider.update(item.provider.id, (provider) => {
+          provider.headers = { ...provider.headers, "HTTP-Referer": "https://opencode.ai/", "X-Title": "opencode" };
+        });
+        for (const modelID of [ID11.make("gpt-5-chat-latest"), ID11.make("openai/gpt-5-chat")]) {
+          if (!item.models.has(modelID))
+            continue;
+          evt.model.update(item.provider.id, modelID, (model) => {
+            model.enabled = false;
+          });
+        }
+      }
+    });
+  })
+});
+
+export { OpenRouterPlugin2 };

package/dist/chunks/worktree-egz44y69.js

@@ -0,0 +1,141 @@
+import {
+  ID12,
+  aisdk2,
+  mergeOverlay2
+} from "./worktree-9qn3qky1.js";
+import {
+  ID11,
+  VariantID2,
+  Info25,
+  compatibility2
+} from "./worktree-esam66tc.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/modal/models.ts
+var exports_models2 = {};
+__export(exports_models2, {
+  ModalModels: () => exports_models2,
+  get: () => get3
+});
+import { Money } from "@opencode/schema/money";
+import { Option, Schema } from "effect";
+var providerID = ID12.make("modal");
+var ReasoningOption = Schema.Struct({
+  type: Schema.Literal("effort"),
+  values: Schema.Array(Schema.NullOr(Schema.String))
+});
+var RemoteModel = Schema.Struct({
+  id: Schema.String,
+  base_model_id: Schema.optional(Schema.String),
+  hugging_face_id: Schema.optional(Schema.String),
+  name: Schema.optional(Schema.String),
+  input_modalities: Schema.optional(Schema.Array(Schema.String)),
+  output_modalities: Schema.optional(Schema.Array(Schema.String)),
+  context_length: Schema.optional(Schema.Number),
+  max_output_length: Schema.optional(Schema.Number),
+  pricing: Schema.optional(Schema.Struct({
+    prompt: Schema.optional(Schema.Union([Schema.String, Schema.Number])),
+    completion: Schema.optional(Schema.Union([Schema.String, Schema.Number])),
+    input_cache_read: Schema.optional(Schema.Union([Schema.String, Schema.Number]))
+  })),
+  supported_sampling_parameters: Schema.optional(Schema.Array(Schema.String)),
+  supported_features: Schema.optional(Schema.Array(Schema.String)),
+  reasoning_options: Schema.optional(Schema.Array(ReasoningOption)),
+  interleaved: Schema.optional(Schema.Union([
+    Schema.Boolean,
+    Schema.Struct({
+      field: Schema.Literals(["reasoning", "reasoning_content", "reasoning_details"])
+    })
+  ]))
+});
+var Response = Schema.Struct({ data: Schema.Array(Schema.Unknown) });
+var decodeResponse = Schema.decodeUnknownSync(Response);
+var decodeModel = Schema.decodeUnknownOption(RemoteModel);
+async function get3(baseURL, apiKey, existing) {
+  const response = await fetch(`${baseURL.replace(/\/+$/, "")}/models`, {
+    headers: {
+      Authorization: `Bearer ${apiKey}`
+    },
+    signal: AbortSignal.timeout(3000)
+  });
+  if (!response.ok)
+    throw new Error(`Failed to fetch Modal models: ${response.status}`);
+  const remote = decodeResponse(await response.json()).data.flatMap((raw) => {
+    const model = Option.getOrUndefined(decodeModel(raw));
+    return model ? [model] : [];
+  });
+  const templates = new Map(existing.map((model) => [model.id, model]));
+  const result = new Map;
+  for (const item of remote) {
+    const template = templates.get(ID11.make(item.base_model_id ?? item.hugging_face_id ?? item.id));
+    const id = ID11.make(item.id);
+    result.set(id, build(id, item, baseURL, template));
+  }
+  return result;
+}
+function price(value, fallback) {
+  if (value === undefined)
+    return fallback;
+  const parsed = Number(value) * 1e6;
+  return Number.isFinite(parsed) ? Money.USDPerMillionTokens.make(parsed) : fallback;
+}
+function limit(value, fallback) {
+  const parsed = value === undefined ? fallback : Math.trunc(value);
+  return Number.isInteger(parsed) && parsed >= 0 ? parsed : fallback;
+}
+function build(id, remote, baseURL, previous) {
+  const cost = previous?.cost[0];
+  const input = previous?.limit.input;
+  return Info25.make({
+    ...Info25.default(providerID, id),
+    id,
+    modelID: ID11.make(remote.id),
+    providerID,
+    name: remote.name ?? previous?.name ?? remote.id,
+    family: previous?.family,
+    compatibility: remote.interleaved === undefined ? previous?.compatibility : compatibility2(remote.interleaved) ?? previous?.compatibility,
+    package: aisdk2("@ai-sdk/openai-compatible"),
+    settings: mergeOverlay2(previous?.settings, { baseURL }),
+    headers: previous?.headers,
+    body: previous?.body,
+    capabilities: {
+      tools: remote.supported_features?.includes("tools") ?? previous?.capabilities.tools ?? true,
+      input: remote.input_modalities ?? previous?.capabilities.input ?? ["text"],
+      output: remote.output_modalities ?? previous?.capabilities.output ?? ["text"]
+    },
+    variants: remote.reasoning_options === undefined ? previous?.variants ?? [] : variants(remote),
+    time: previous?.time ?? { released: 0 },
+    cost: [
+      {
+        input: price(remote.pricing?.prompt, cost?.input ?? Money.USDPerMillionTokens.zero),
+        output: price(remote.pricing?.completion, cost?.output ?? Money.USDPerMillionTokens.zero),
+        cache: {
+          read: price(remote.pricing?.input_cache_read, cost?.cache.read ?? Money.USDPerMillionTokens.zero),
+          write: cost?.cache.write ?? Money.USDPerMillionTokens.zero
+        }
+      }
+    ],
+    status: previous?.status ?? "active",
+    enabled: previous?.enabled ?? true,
+    limit: {
+      context: limit(remote.context_length, previous?.limit.context ?? 0),
+      ...input === undefined ? {} : { input },
+      output: limit(remote.max_output_length, previous?.limit.output ?? 0)
+    }
+  });
+}
+function variants(remote) {
+  const seen = new Map;
+  for (const option of remote.reasoning_options ?? []) {
+    for (const value of option.values) {
+      const effort = value ?? "none";
+      if (!seen.has(effort))
+        seen.set(effort, { id: VariantID2.make(effort), settings: { reasoningEffort: effort } });
+    }
+  }
+  return [...seen.values()];
+}
+
+export { get3, exports_models2 };

package/dist/chunks/worktree-eh3zwz77.js

@@ -0,0 +1,31 @@
+// src/github-copilot/responses/tool/code-interpreter.ts
+import { createProviderToolFactoryWithOutputSchema } from "@ai-sdk/provider-utils";
+import { z } from "zod/v4";
+var codeInterpreterInputSchema2 = z.object({
+  code: z.string().nullish(),
+  containerId: z.string()
+});
+var codeInterpreterOutputSchema2 = z.object({
+  outputs: z.array(z.discriminatedUnion("type", [
+    z.object({ type: z.literal("logs"), logs: z.string() }),
+    z.object({ type: z.literal("image"), url: z.string() })
+  ])).nullish()
+});
+var codeInterpreterArgsSchema2 = z.object({
+  container: z.union([
+    z.string(),
+    z.object({
+      fileIds: z.array(z.string()).optional()
+    })
+  ]).optional()
+});
+var codeInterpreterToolFactory2 = createProviderToolFactoryWithOutputSchema({
+  id: "openai.code_interpreter",
+  inputSchema: codeInterpreterInputSchema2,
+  outputSchema: codeInterpreterOutputSchema2
+});
+var codeInterpreter2 = (args = {}) => {
+  return codeInterpreterToolFactory2(args);
+};
+
+export { codeInterpreterInputSchema2, codeInterpreterOutputSchema2, codeInterpreterArgsSchema2, codeInterpreterToolFactory2, codeInterpreter2 };

package/dist/chunks/worktree-emrn6kk6.js

@@ -0,0 +1,100 @@
+// src/database/drizzle/internal/drizzle-utils.ts
+import { Column, getColumnTable } from "drizzle-orm/column";
+import { is } from "drizzle-orm/entity";
+import { Param, SQL } from "drizzle-orm/sql/sql";
+import { SQLiteViewBase } from "drizzle-orm/sqlite-core/view-base";
+import { Subquery } from "drizzle-orm/subquery";
+import { Table, getTableName } from "drizzle-orm/table";
+import { ViewBaseConfig } from "drizzle-orm/view-common";
+var TableSymbol = Table.Symbol;
+function getTableColumnsRuntime2(table) {
+  return table[TableSymbol.Columns];
+}
+function getViewSelectedFieldsRuntime2(view) {
+  return view[ViewBaseConfig];
+}
+function jitCompatCheck2(isEnabled) {
+  if (!isEnabled)
+    return false;
+  try {
+    return new Function("input", '"use strict"; return input;')(true) === true;
+  } catch {
+    return false;
+  }
+}
+function orderSelectedFields2(fields, pathPrefix) {
+  return Object.entries(fields).flatMap(([name, field]) => {
+    const path = pathPrefix ? [...pathPrefix, name] : [name];
+    if (is(field, Column))
+      return [{ path, field, fieldType: "Column", column: field }];
+    if (is(field, SQL))
+      return [{ path, field, fieldType: "SQL" }];
+    if (is(field, SQL.Aliased))
+      return [{ path, field, fieldType: "SQL.Aliased" }];
+    if (is(field, Subquery))
+      return [{ path, field, fieldType: "Subquery" }];
+    if (is(field, Table))
+      return orderSelectedFields2(getTableColumnsRuntime2(field), path);
+    return orderSelectedFields2(field, path);
+  });
+}
+function resolveNullableObjectPaths2(columns, joinsNotNullableMap) {
+  if (!joinsNotNullableMap)
+    return;
+  const tableOf = columns.filter((column) => column.path.length > 1 && column.fieldType === "Column").reduce((result, column) => {
+    const key = column.path[0];
+    const tableName = getTableName(getColumnTable(column.field));
+    const current = result[key];
+    result[key] = current === undefined ? tableName : current === tableName ? current : false;
+    return result;
+  }, {});
+  return Object.entries(tableOf).filter(([, tableName]) => typeof tableName === "string" && !joinsNotNullableMap[tableName]).map(([key]) => key);
+}
+function mapUpdateSet2(table, values) {
+  const entries = Object.entries(values).filter(([, value]) => value !== undefined);
+  if (entries.length === 0)
+    throw new Error("No values to set");
+  return Object.fromEntries(entries.map(([key, value]) => [
+    key,
+    is(value, SQL) || is(value, Column) ? value : new Param(value, getTableColumnsRuntime2(table)[key])
+  ]));
+}
+function mapResultRow2(columns, row, joinsNotNullableMap) {
+  const nullifyMap = {};
+  const result = {};
+  columns.forEach((column, columnIndex) => {
+    const decoder = is(column.field, Column) ? column.field : is(column.field, SQL) ? column.field.decoder : is(column.field, Subquery) ? column.field._.sql.decoder : column.field.sql.decoder;
+    const rawValue = row[columnIndex];
+    const value = rawValue === null ? null : decoder.mapFromDriverValue(rawValue);
+    const objectName = column.path[0];
+    let node = result;
+    column.path.forEach((pathChunk, pathChunkIndex) => {
+      if (pathChunkIndex === column.path.length - 1) {
+        node[pathChunk] = value;
+        return;
+      }
+      node[pathChunk] = node[pathChunk] ?? {};
+      node = node[pathChunk];
+    });
+    if (joinsNotNullableMap && is(column.field, Column) && column.path.length === 2 && objectName) {
+      const tableName = getTableName(getColumnTable(column.field));
+      nullifyMap[objectName] = !(objectName in nullifyMap) && value === null ? tableName : typeof nullifyMap[objectName] === "string" && nullifyMap[objectName] !== tableName ? false : nullifyMap[objectName];
+    }
+  });
+  Object.entries(nullifyMap).forEach(([objectName, tableName]) => {
+    if (typeof tableName === "string" && !joinsNotNullableMap?.[tableName])
+      result[objectName] = null;
+  });
+  return result;
+}
+function getTableLikeName2(table) {
+  if (is(table, Subquery))
+    return table._.alias;
+  if (is(table, SQLiteViewBase))
+    return getViewSelectedFieldsRuntime2(table).name;
+  if (is(table, SQL))
+    return;
+  return table[table[TableSymbol.IsAlias] ? TableSymbol.Name : TableSymbol.BaseName];
+}
+
+export { getTableColumnsRuntime2, getViewSelectedFieldsRuntime2, jitCompatCheck2, orderSelectedFields2, resolveNullableObjectPaths2, mapUpdateSet2, mapResultRow2, getTableLikeName2 };