@opencode-ai/core 0.0.0-dev-17471

package/dist/chunks/location-mutation-8v47shgf.js

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

package/dist/chunks/location-mutation-8vhzxx5g.js

@@ -0,0 +1,25 @@
+import {
+  AbsolutePath
+} from "./location-mutation-j07kk359.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/worktree/directory.ts
+var exports_directory = {};
+__export(exports_directory, {
+  canonical: () => canonical,
+  WorktreeDirectory: () => exports_directory,
+  DirectoryUnavailableError: () => DirectoryUnavailableError
+});
+import { Effect, Schema } from "effect";
+class DirectoryUnavailableError extends Schema.TaggedErrorClass()("Worktree.DirectoryUnavailableError", { directory: AbsolutePath }) {
+}
+var canonical = Effect.fnUntraced(function* (fs, input) {
+  const resolved = AbsolutePath.make(yield* fs.resolve(input));
+  if (!(yield* fs.isDir(resolved)))
+    return yield* new DirectoryUnavailableError({ directory: input });
+  return resolved;
+});
+
+export { DirectoryUnavailableError, canonical, exports_directory };

package/dist/chunks/location-mutation-8w9tzfz1.js

@@ -0,0 +1,14 @@
+// src/util/lazy.ts
+function lazy(fn) {
+  let value;
+  let loaded = false;
+  return () => {
+    if (loaded)
+      return value;
+    loaded = true;
+    value = fn();
+    return value;
+  };
+}
+
+export { lazy };

package/dist/chunks/location-mutation-8ywqk2j9.js

@@ -0,0 +1,50 @@
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/session/usage.ts
+var exports_usage = {};
+__export(exports_usage, {
+  tokens: () => tokens,
+  record: () => record,
+  calculateCost: () => calculateCost,
+  add: () => add,
+  SessionUsage: () => exports_usage
+});
+import { Money } from "@opencode-ai/schema/money";
+var safe = (value) => Math.max(0, Number.isFinite(value) ? value ?? 0 : 0);
+var tokens = (usage) => ({
+  input: safe(usage?.nonCachedInputTokens),
+  output: safe(usage?.visibleOutputTokens),
+  reasoning: safe(usage?.reasoningTokens),
+  cache: {
+    read: safe(usage?.cacheReadInputTokens),
+    write: safe(usage?.cacheWriteInputTokens)
+  }
+});
+function calculateCost(costs, usage) {
+  const context = usage.input + usage.cache.read + usage.cache.write;
+  const tier = costs.filter((cost2) => cost2.tier?.type === "context" && context > cost2.tier.size).toSorted((a, b) => (b.tier?.size ?? 0) - (a.tier?.size ?? 0))[0];
+  const cost = tier ?? costs.find((cost2) => cost2.tier === undefined);
+  if (!cost)
+    return Money.USD.zero;
+  return Money.USD.make((usage.input * cost.input + (usage.output + usage.reasoning) * cost.output + usage.cache.read * cost.cache.read + usage.cache.write * cost.cache.write) / 1e6);
+}
+var record = (usage, costs) => {
+  const normalized = tokens(usage);
+  return { tokens: normalized, cost: calculateCost(costs, normalized) };
+};
+var add = (a, b) => ({
+  cost: Money.USD.make(a.cost + b.cost),
+  tokens: {
+    input: a.tokens.input + b.tokens.input,
+    output: a.tokens.output + b.tokens.output,
+    reasoning: a.tokens.reasoning + b.tokens.reasoning,
+    cache: {
+      read: a.tokens.cache.read + b.tokens.cache.read,
+      write: a.tokens.cache.write + b.tokens.cache.write
+    }
+  }
+});
+
+export { tokens, calculateCost, record, add, exports_usage };

package/dist/chunks/location-mutation-906y0b6d.js

@@ -0,0 +1,13 @@
+// src/database/migration/20260601202201_amazing_prowler.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260601202201_amazing_prowler",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DROP TABLE \`permission\`;`);
+    });
+  }
+};
+var _20260601202201_amazing_prowler_default = migration;
+
+export { _20260601202201_amazing_prowler_default };

package/dist/chunks/location-mutation-9314w1nf.js

@@ -0,0 +1,272 @@
+import {
+  upgradeIfNeeded
+} from "./location-mutation-8bkmtpp6.js";
+import {
+  SQLiteEffectDatabase
+} from "./location-mutation-g2tksnm3.js";
+import {
+  mapResultRow
+} from "./location-mutation-ma07p6tt.js";
+
+// src/database/drizzle/sqlite-core/effect/session.ts
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import { NoopCache, strategyFor } from "drizzle-orm/cache/core/cache";
+import { MigratorInitError } from "drizzle-orm/effect-core/errors";
+import { EffectDrizzleQueryError, EffectTransactionRollbackError } from "drizzle-orm/effect-core/errors";
+import { entityKind, is } from "drizzle-orm/entity";
+import { getMigrationsToRun } from "drizzle-orm/migrator.utils";
+import { makeJitRqbMapper } from "drizzle-orm/relations";
+import { fillPlaceholders, sql } from "drizzle-orm/sql/sql";
+import { assertUnreachable, makeJitQueryMapper } from "drizzle-orm/utils";
+class SQLiteEffectPreparedQuery {
+  executor;
+  query;
+  logger;
+  cache;
+  queryMetadata;
+  fields;
+  useJitMappers;
+  customResultMapper;
+  isRqbV2Query;
+  rqbConfig;
+  isInTransaction;
+  static [entityKind] = "SQLiteEffectPreparedQuery";
+  joinsNotNullableMap;
+  jitMapper;
+  cacheConfig;
+  effectExecuteMethod;
+  constructor(executor, query, logger, cache, queryMetadata, cacheConfig, fields, executeMethod, useJitMappers, customResultMapper, isRqbV2Query, rqbConfig, isInTransaction = Effect.succeed(false)) {
+    this.executor = executor;
+    this.query = query;
+    this.logger = logger;
+    this.cache = cache;
+    this.queryMetadata = queryMetadata;
+    this.fields = fields;
+    this.useJitMappers = useJitMappers;
+    this.customResultMapper = customResultMapper;
+    this.isRqbV2Query = isRqbV2Query;
+    this.rqbConfig = rqbConfig;
+    this.isInTransaction = isInTransaction;
+    this.effectExecuteMethod = executeMethod;
+    this.cacheConfig = cache.strategy() === "all" && cacheConfig === undefined ? { enabled: true, autoInvalidate: true } : cacheConfig;
+    if (!this.cacheConfig?.enabled) {
+      this.cacheConfig = undefined;
+    }
+  }
+  run(placeholderValues) {
+    return this.executeWithCache(placeholderValues, "run");
+  }
+  all(placeholderValues) {
+    if (this.isRqbV2Query)
+      return this.allRqbV2(placeholderValues);
+    if (!this.fields && !this.customResultMapper) {
+      return this.executeWithCache(placeholderValues, "all");
+    }
+    return this.executeWithCache(placeholderValues, "values", (rows) => this.mapAllResult(rows));
+  }
+  get(placeholderValues) {
+    if (this.isRqbV2Query)
+      return this.getRqbV2(placeholderValues);
+    if (!this.fields && !this.customResultMapper) {
+      return this.executeWithCache(placeholderValues, "get");
+    }
+    return this.executeWithCache(placeholderValues, "values", (rows) => this.mapGetResult(rows));
+  }
+  values(placeholderValues) {
+    return this.executeWithCache(placeholderValues, "values");
+  }
+  execute(placeholderValues) {
+    return this[this.effectExecuteMethod](placeholderValues);
+  }
+  mapRunResult(result, _isFromBatch) {
+    return result;
+  }
+  mapAllResult(rows, isFromBatch) {
+    if (isFromBatch) {
+      rows = Array.isArray(rows) ? rows : [];
+    }
+    if (!this.fields && !this.customResultMapper) {
+      return rows;
+    }
+    if (this.isRqbV2Query) {
+      return this.useJitMappers ? (this.jitMapper = this.jitMapper ?? makeJitRqbMapper(this.rqbConfig))(rows) : this.customResultMapper(rows);
+    }
+    if (this.customResultMapper) {
+      return this.customResultMapper(rows);
+    }
+    return this.useJitMappers ? (this.jitMapper = this.jitMapper ?? makeJitQueryMapper(this.fields, this.joinsNotNullableMap))(rows) : rows.map((row) => mapResultRow(this.fields, row, this.joinsNotNullableMap));
+  }
+  mapGetResult(rows, isFromBatch) {
+    if (isFromBatch) {
+      rows = Array.isArray(rows) ? rows : [];
+    }
+    if (!this.fields && !this.customResultMapper) {
+      return Array.isArray(rows) ? rows[0] : rows;
+    }
+    const row = Array.isArray(rows) ? rows[0] : rows;
+    if (!row)
+      return;
+    if (this.isRqbV2Query) {
+      return this.useJitMappers ? (this.jitMapper = this.jitMapper ?? makeJitRqbMapper(this.rqbConfig))([
+        row
+      ]) : this.customResultMapper([row]);
+    }
+    if (this.customResultMapper) {
+      return this.customResultMapper([row]);
+    }
+    return this.useJitMappers ? (this.jitMapper = this.jitMapper ?? makeJitQueryMapper(this.fields, this.joinsNotNullableMap))([row])[0] : mapResultRow(this.fields, row, this.joinsNotNullableMap);
+  }
+  allRqbV2(placeholderValues) {
+    return this.executeWithCache(placeholderValues, "all", (rows) => this.mapAllResult(rows));
+  }
+  getRqbV2(placeholderValues) {
+    return this.executeWithCache(placeholderValues, "get", (row) => row === undefined ? undefined : this.mapGetResult(row));
+  }
+  executeWithCache(placeholderValues, executeMethod, mapResult) {
+    return Effect.gen({ self: this }, function* () {
+      const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
+      yield* this.logger.logQuery(this.query.sql, params);
+      return yield* this.queryWithCache(this.query.sql, params, Effect.suspend(() => this.executor(params, executeMethod)), mapResult);
+    });
+  }
+  mapCachedResult(result, mapResult) {
+    if (!mapResult)
+      return Effect.succeed(result);
+    return Effect.try({
+      try: () => mapResult(result),
+      catch: (cause) => cause
+    });
+  }
+  queryWithCache(queryString, params, query, mapResult) {
+    return Effect.gen({ self: this }, function* () {
+      if (this.queryMetadata?.type === "select" && this.cacheConfig?.enabled && (yield* this.isInTransaction)) {
+        return yield* this.mapCachedResult(yield* query, mapResult);
+      }
+      const cacheStrat = !is(this.cache.cache, NoopCache) ? yield* Effect.tryPromise(() => strategyFor(queryString, params, this.queryMetadata, this.cacheConfig)) : { type: "skip" };
+      if (cacheStrat.type === "skip") {
+        return yield* this.mapCachedResult(yield* query, mapResult);
+      }
+      if (cacheStrat.type === "invalidate") {
+        const result = yield* query;
+        yield* this.cache.onMutate({ tables: cacheStrat.tables });
+        return yield* this.mapCachedResult(result, mapResult);
+      }
+      if (cacheStrat.type === "try") {
+        if (yield* this.isInTransaction) {
+          return yield* this.mapCachedResult(yield* query, mapResult);
+        }
+        const { tables, key, isTag, autoInvalidate, config } = cacheStrat;
+        const fromCache = yield* this.cache.get(key, tables, isTag, autoInvalidate);
+        if (typeof fromCache !== "undefined") {
+          return yield* this.mapCachedResult(fromCache, mapResult);
+        }
+        const result = yield* query;
+        yield* this.cache.put(key, result, autoInvalidate ? tables : [], isTag, config);
+        return yield* this.mapCachedResult(result, mapResult);
+      }
+      assertUnreachable(cacheStrat);
+    }).pipe(Effect.catch((e) => {
+      return Effect.fail(new EffectDrizzleQueryError({ query: queryString, params, cause: Cause.fail(e) }));
+    }));
+  }
+  getQuery() {
+    return this.query;
+  }
+  mapResult(response, isFromBatch) {
+    switch (this.effectExecuteMethod) {
+      case "run": {
+        return this.mapRunResult(response, isFromBatch);
+      }
+      case "all": {
+        return this.mapAllResult(response, isFromBatch);
+      }
+      case "get": {
+        return this.mapGetResult(response, isFromBatch);
+      }
+    }
+  }
+}
+
+class SQLiteEffectSession {
+  dialect;
+  static [entityKind] = "SQLiteEffectSession";
+  constructor(dialect) {
+    this.dialect = dialect;
+  }
+  prepareOneTimeQuery(query, fields, executeMethod, customResultMapper, queryMetadata, cacheConfig) {
+    return this.prepareQuery(query, fields, executeMethod, customResultMapper, queryMetadata, cacheConfig);
+  }
+  prepareOneTimeRelationalQuery(query, fields, executeMethod, customResultMapper, config) {
+    return this.prepareRelationalQuery(query, fields, executeMethod, customResultMapper, config);
+  }
+  run(query) {
+    return this.prepareQuery(this.dialect.sqlToQuery(query), undefined, "run").run();
+  }
+  all(query) {
+    return this.prepareQuery(this.dialect.sqlToQuery(query), undefined, "all").all();
+  }
+  get(query) {
+    return this.prepareQuery(this.dialect.sqlToQuery(query), undefined, "get").get();
+  }
+  values(query) {
+    return this.prepareQuery(this.dialect.sqlToQuery(query), undefined, "all").values();
+  }
+  count(query) {
+    return this.values(query).pipe(Effect.map((result) => result[0]?.[0] ?? 0));
+  }
+}
+
+class SQLiteEffectTransaction extends SQLiteEffectDatabase {
+  relations;
+  static [entityKind] = "SQLiteEffectTransaction";
+  constructor(dialect, session, relations) {
+    super(dialect, session, relations);
+    this.relations = relations;
+  }
+  rollback() {
+    return new EffectTransactionRollbackError;
+  }
+}
+var migrate = Effect.fn("migrate")(function* (migrations, session, config) {
+  const migrationsTable = typeof config === "string" ? "__drizzle_migrations" : config.migrationsTable ?? "__drizzle_migrations";
+  const { newDb } = yield* upgradeIfNeeded(migrationsTable, session, migrations);
+  if (newDb) {
+    yield* session.run(sql`
+		CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsTable)} (
+			id INTEGER PRIMARY KEY,
+			hash text NOT NULL,
+			created_at numeric,
+			name text,
+			applied_at TEXT
+		)
+	`);
+  }
+  const dbMigrations = yield* session.all(sql`SELECT id, hash, created_at, name FROM ${sql.identifier(migrationsTable)}`);
+  if (typeof config === "object" && config.init) {
+    if (dbMigrations.length) {
+      return yield* new MigratorInitError({ exitCode: "databaseMigrations" });
+    }
+    if (migrations.length > 1) {
+      return yield* new MigratorInitError({ exitCode: "localMigrations" });
+    }
+    const [migration] = migrations;
+    if (!migration)
+      return;
+    yield* session.run(sql`insert into ${sql.identifier(migrationsTable)} ("hash", "created_at", "name", "applied_at") values(${migration.hash}, ${migration.folderMillis}, ${migration.name}, ${new Date().toISOString()})`);
+    return;
+  }
+  const migrationsToRun = getMigrationsToRun({ localMigrations: migrations, dbMigrations });
+  if (migrationsToRun.length === 0)
+    return;
+  yield* session.transaction((tx) => Effect.gen(function* () {
+    for (const migration of migrationsToRun) {
+      for (const stmt of migration.sql) {
+        yield* tx.run(sql.raw(stmt));
+      }
+      yield* tx.run(sql`insert into ${sql.identifier(migrationsTable)} ("hash", "created_at", "name", "applied_at") values(${migration.hash}, ${migration.folderMillis}, ${migration.name}, ${new Date().toISOString()})`);
+    }
+  }));
+});
+
+export { SQLiteEffectPreparedQuery, SQLiteEffectSession, SQLiteEffectTransaction, migrate };

package/dist/chunks/location-mutation-93qdgxxd.js

@@ -0,0 +1,30 @@
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/session/model-http.ts
+var exports_model_http = {};
+__export(exports_model_http, {
+  middleware: () => middleware,
+  SessionModelHttp: () => exports_model_http
+});
+import { Effect, Stream } from "effect";
+import { HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+var middleware = (hooks, input) => (request, handler) => Effect.gen(function* () {
+  const before = yield* hooks.trigger("session", "http.request", {
+    ...input,
+    request: yield* HttpClientRequest.toWeb(request)
+  });
+  let sent = HttpClientRequest.fromWeb(before.request);
+  if (before.request.body)
+    sent = HttpClientRequest.bodyUint8Array(sent, new Uint8Array(yield* Effect.promise(() => before.request.clone().arrayBuffer())), before.request.headers.get("content-type") ?? undefined);
+  const response = yield* handler(sent);
+  const after = yield* hooks.trigger("session", "http.response", {
+    ...input,
+    request: before.request,
+    response: new Response([204, 205, 304].includes(response.status) ? null : yield* Stream.toReadableStreamEffect(response.stream), { status: response.status, headers: response.headers })
+  });
+  return HttpClientResponse.fromWeb(sent, after.response);
+}).pipe(Effect.mapError((cause) => cause instanceof Error ? cause : new Error(String(cause))));
+
+export { middleware, exports_model_http };

package/dist/chunks/location-mutation-999qd968.js

@@ -0,0 +1,84 @@
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/v1/config/lsp.ts
+var exports_lsp = {};
+__export(exports_lsp, {
+  requiresExtensionsForCustomServers: () => requiresExtensionsForCustomServers,
+  builtinServerIds: () => builtinServerIds,
+  Info: () => Info,
+  Entry: () => Entry,
+  Disabled: () => Disabled,
+  ConfigLSPV1: () => exports_lsp
+});
+import { Schema } from "effect";
+var Disabled = Schema.Struct({
+  disabled: Schema.Literal(true)
+}).pipe((schema) => schema);
+var Entry = Schema.Union([
+  Disabled,
+  Schema.Struct({
+    command: Schema.mutable(Schema.Array(Schema.String)),
+    extensions: Schema.optional(Schema.mutable(Schema.Array(Schema.String))),
+    disabled: Schema.optional(Schema.Boolean),
+    env: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+    initialization: Schema.optional(Schema.Record(Schema.String, Schema.Unknown))
+  })
+]).pipe((schema) => schema);
+var builtinServerIds = [
+  "deno",
+  "typescript",
+  "vue",
+  "eslint",
+  "oxlint",
+  "biome",
+  "gopls",
+  "ruby-lsp",
+  "ty",
+  "pyright",
+  "elixir-ls",
+  "zls",
+  "csharp",
+  "razor",
+  "fsharp",
+  "sourcekit-lsp",
+  "rust",
+  "clangd",
+  "svelte",
+  "astro",
+  "jdtls",
+  "kotlin-ls",
+  "yaml-ls",
+  "lua-ls",
+  "php intelephense",
+  "prisma",
+  "dart",
+  "ocaml-lsp",
+  "bash",
+  "terraform",
+  "texlab",
+  "dockerfile",
+  "gleam",
+  "clojure-lsp",
+  "nixd",
+  "tinymist",
+  "haskell-language-server",
+  "julials"
+];
+var requiresExtensionsForCustomServers = Schema.makeFilter((data) => {
+  if (typeof data === "boolean")
+    return;
+  const ids = new Set(builtinServerIds);
+  const ok = Object.entries(data).every(([id, config]) => {
+    if ("disabled" in config && config.disabled)
+      return true;
+    if (ids.has(id))
+      return true;
+    return "extensions" in config && Boolean(config.extensions);
+  });
+  return ok ? undefined : "For custom LSP servers, 'extensions' array is required.";
+});
+var Info = Schema.Union([Schema.Boolean, Schema.Record(Schema.String, Entry)]).check(requiresExtensionsForCustomServers).pipe((schema) => schema);
+
+export { Disabled, Entry, builtinServerIds, requiresExtensionsForCustomServers, Info, exports_lsp };

package/dist/chunks/location-mutation-9d2xhdr4.js

@@ -0,0 +1,111 @@
+import {
+  ProjectTable
+} from "./location-mutation-88jbfw8z.js";
+import {
+  directoryColumn,
+  pathColumn
+} from "./location-mutation-zbqqnp0n.js";
+import {
+  Timestamps
+} from "./location-mutation-sem2g21k.js";
+
+// src/session/sql.ts
+import { sqliteTable, text, integer, index, primaryKey, real, uniqueIndex } from "drizzle-orm/sqlite-core";
+import { sql } from "drizzle-orm";
+var SessionTable = sqliteTable("session_v2", {
+  id: text().$type().primaryKey(),
+  project_id: text().$type().notNull().references(() => ProjectTable.id, { onDelete: "cascade" }),
+  workspace_id: text().$type(),
+  parent_id: text().$type(),
+  fork_session_id: text().$type(),
+  fork_boundary: text({ mode: "json" }).$type(),
+  slug: text().notNull(),
+  directory: directoryColumn().notNull(),
+  path: pathColumn(),
+  title: text(),
+  version: text().notNull(),
+  share_url: text(),
+  summary_additions: integer(),
+  summary_deletions: integer(),
+  summary_files: integer(),
+  summary_diffs: text({ mode: "json" }).$type(),
+  metadata: text({ mode: "json" }).$type(),
+  cost: real().notNull().default(0),
+  tokens_input: integer().notNull().default(0),
+  tokens_output: integer().notNull().default(0),
+  tokens_reasoning: integer().notNull().default(0),
+  tokens_cache_read: integer().notNull().default(0),
+  tokens_cache_write: integer().notNull().default(0),
+  revert: text({ mode: "json" }).$type(),
+  permission: text({ mode: "json" }).$type(),
+  agent: text(),
+  model: text({ mode: "json" }).$type(),
+  ...Timestamps,
+  time_compacting: integer(),
+  time_archived: integer(),
+  time_suspended: integer(),
+  resume_attempts: integer().notNull().default(0)
+}, (table) => [
+  index("session_v2_project_idx").on(table.project_id),
+  index("session_v2_workspace_idx").on(table.workspace_id),
+  index("session_v2_parent_idx").on(table.parent_id),
+  index("session_v2_time_suspended_idx").on(table.time_suspended).where(sql`${table.time_suspended} is not null`)
+]);
+var SessionMessageTable = sqliteTable("session_message", {
+  id: text().$type().primaryKey(),
+  session_id: text().$type().notNull().references(() => SessionTable.id, { onDelete: "cascade" }),
+  type: text().$type().notNull(),
+  seq: integer().notNull(),
+  ...Timestamps,
+  data: text({ mode: "json" }).notNull().$type()
+}, (table) => [
+  uniqueIndex("session_message_session_seq_idx").on(table.session_id, table.seq),
+  index("session_message_session_type_seq_idx").on(table.session_id, table.type, table.seq),
+  index("session_message_session_time_created_id_idx").on(table.session_id, table.time_created, table.id),
+  index("session_message_time_created_idx").on(table.time_created)
+]);
+var SessionPendingTable = sqliteTable("session_pending", {
+  id: text().$type().primaryKey(),
+  session_id: text().$type().notNull().references(() => SessionTable.id, { onDelete: "cascade" }),
+  type: text().$type().notNull(),
+  data: text({ mode: "json" }).$type().notNull(),
+  delivery: text().$type(),
+  admitted_seq: integer().notNull(),
+  time_created: integer().notNull().$default(() => Date.now())
+}, (table) => [
+  index("session_pending_session_delivery_seq_idx").on(table.session_id, table.delivery, table.admitted_seq),
+  uniqueIndex("session_pending_session_compaction_idx").on(table.session_id).where(sql`${table.type} = 'compaction'`),
+  uniqueIndex("session_pending_session_admitted_seq_idx").on(table.session_id, table.admitted_seq)
+]);
+var SessionInboxTable = sqliteTable("session_inbox", {
+  id: text().$type().primaryKey(),
+  session_id: text().$type().notNull().references(() => SessionTable.id, { onDelete: "cascade" }),
+  type: text().$type().notNull(),
+  payload: text({ mode: "json" }).$type().notNull(),
+  delivery: text().$type().notNull(),
+  enqueued_seq: integer().notNull(),
+  time_created: integer().notNull().$default(() => Date.now())
+}, (table) => [
+  index("session_inbox_session_delivery_seq_idx").on(table.session_id, table.delivery, table.enqueued_seq),
+  uniqueIndex("session_inbox_session_enqueued_seq_idx").on(table.session_id, table.enqueued_seq)
+]);
+var InstructionEntryTable = sqliteTable("instruction_entry", {
+  session_id: text().$type().notNull().references(() => SessionTable.id, { onDelete: "cascade" }),
+  key: text().notNull(),
+  value: text({ mode: "json" }).$type(),
+  removed: integer({ mode: "boolean" }).notNull().default(false),
+  ...Timestamps
+}, (table) => [primaryKey({ columns: [table.session_id, table.key] })]);
+var InstructionBlobTable = sqliteTable("instruction_blob", {
+  hash: text().$type().primaryKey(),
+  value: text({ mode: "json" }).$type()
+});
+var InstructionStateTable = sqliteTable("instruction_state", {
+  session_id: text().$type().primaryKey().references(() => SessionTable.id, { onDelete: "cascade" }),
+  epoch_start: integer().notNull(),
+  through_seq: integer().notNull(),
+  initial_values: text({ mode: "json" }).notNull().$type(),
+  current_values: text({ mode: "json" }).notNull().$type()
+});
+
+export { SessionTable, SessionMessageTable, SessionPendingTable, SessionInboxTable, InstructionEntryTable, InstructionBlobTable, InstructionStateTable };

package/dist/chunks/location-mutation-9dct5xhx.js

@@ -0,0 +1,21 @@
+// src/database/migration/20260225215848_workspace.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260225215848_workspace",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`workspace\` (
+          \`id\` text PRIMARY KEY,
+          \`branch\` text,
+          \`project_id\` text NOT NULL,
+          \`config\` text NOT NULL,
+          CONSTRAINT \`fk_workspace_project_id_project_id_fk\` FOREIGN KEY (\`project_id\`) REFERENCES \`project\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+    });
+  }
+};
+var _20260225215848_workspace_default = migration;
+
+export { _20260225215848_workspace_default };

package/dist/chunks/location-mutation-9f0rnpkn.js

@@ -0,0 +1,16 @@
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/v1/config/plugin.ts
+var exports_plugin = {};
+__export(exports_plugin, {
+  Spec: () => Spec,
+  Options: () => Options,
+  ConfigPluginV1: () => exports_plugin
+});
+import { Schema } from "effect";
+var Options = Schema.Record(Schema.String, Schema.Unknown);
+var Spec = Schema.Union([Schema.String, Schema.mutable(Schema.Tuple([Schema.String, Options]))]);
+
+export { Options, Spec, exports_plugin };