@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-ma07p6tt.js

@@ -0,0 +1,83 @@
+// 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 getTableColumnsRuntime(table) {
+  return table[TableSymbol.Columns];
+}
+function getViewSelectedFieldsRuntime(view) {
+  return view[ViewBaseConfig];
+}
+function jitCompatCheck(isEnabled) {
+  if (!isEnabled)
+    return false;
+  try {
+    return new Function("input", '"use strict"; return input;')(true) === true;
+  } catch {
+    return false;
+  }
+}
+function orderSelectedFields(fields, pathPrefix) {
+  return Object.entries(fields).flatMap(([name, field]) => {
+    const path = pathPrefix ? [...pathPrefix, name] : [name];
+    if (is(field, Column) || is(field, SQL) || is(field, SQL.Aliased) || is(field, Subquery)) {
+      return [{ path, field }];
+    }
+    if (is(field, Table))
+      return orderSelectedFields(getTableColumnsRuntime(field), path);
+    return orderSelectedFields(field, path);
+  });
+}
+function mapUpdateSet(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, getTableColumnsRuntime(table)[key])
+  ]));
+}
+function mapResultRow(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 getTableLikeName(table) {
+  if (is(table, Subquery))
+    return table._.alias;
+  if (is(table, SQLiteViewBase))
+    return getViewSelectedFieldsRuntime(table).name;
+  if (is(table, SQL))
+    return;
+  return table[table[TableSymbol.IsAlias] ? TableSymbol.Name : TableSymbol.BaseName];
+}
+
+export { getTableColumnsRuntime, getViewSelectedFieldsRuntime, jitCompatCheck, orderSelectedFields, mapUpdateSet, mapResultRow, getTableLikeName };

package/dist/chunks/permission-ma60vzgv.js

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

package/dist/chunks/permission-mf0hyk7z.js

@@ -0,0 +1,18 @@
+import {
+  Timestamps
+} from "./permission-sem2g21k.js";
+
+// src/credential/sql.ts
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+var CredentialTable = sqliteTable("credential", {
+  id: text().$type().primaryKey(),
+  integration_id: text().$type(),
+  label: text().notNull(),
+  value: text({ mode: "json" }).$type().notNull(),
+  connector_id: text(),
+  method_id: text(),
+  active: integer({ mode: "boolean" }),
+  ...Timestamps
+});
+
+export { CredentialTable };

package/dist/chunks/permission-mwceq5am.js

@@ -0,0 +1,102 @@
+import {
+  getViewSelectedFieldsRuntime,
+  orderSelectedFields
+} from "./permission-ma07p6tt.js";
+
+// src/database/drizzle/sqlite-core/effect/select.ts
+import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";
+import { entityKind, is } from "drizzle-orm/entity";
+import { SQL } from "drizzle-orm/sql/sql";
+import { SQLiteSelectQueryBuilderBase } from "drizzle-orm/sqlite-core/query-builders/select";
+import { SQLiteViewBase } from "drizzle-orm/sqlite-core/view-base";
+import { Subquery } from "drizzle-orm/subquery";
+import { getTableColumns } from "drizzle-orm/utils";
+class SQLiteEffectSelectBuilder {
+  static [entityKind] = "SQLiteEffectSelectBuilder";
+  fields;
+  session;
+  dialect;
+  withList;
+  distinct;
+  constructor(config) {
+    this.fields = config.fields;
+    this.session = config.session;
+    this.dialect = config.dialect;
+    this.withList = config.withList;
+    this.distinct = config.distinct;
+  }
+  from(source) {
+    const isPartialSelect = !!this.fields;
+    let fields;
+    if (this.fields) {
+      fields = this.fields;
+    } else if (is(source, Subquery)) {
+      fields = Object.fromEntries(Object.keys(source._.selectedFields).map((key) => [
+        key,
+        source[key]
+      ]));
+    } else if (is(source, SQLiteViewBase)) {
+      fields = getViewSelectedFieldsRuntime(source).selectedFields;
+    } else if (is(source, SQL)) {
+      fields = {};
+    } else {
+      fields = getTableColumns(source);
+    }
+    return new SQLiteEffectSelectBase({
+      table: source,
+      fields,
+      isPartialSelect,
+      session: this.session,
+      dialect: this.dialect,
+      withList: this.withList,
+      distinct: this.distinct
+    });
+  }
+}
+
+class SQLiteEffectSelectBase extends SQLiteSelectQueryBuilderBase {
+  static [entityKind] = "SQLiteEffectSelect";
+  get effectConfig() {
+    return this.config;
+  }
+  getSQL() {
+    return this.dialect.buildSelectQuery(this.effectConfig);
+  }
+  _prepare(isOneTimeQuery = true) {
+    if (!this.session) {
+      throw new Error("Cannot execute a query on a query builder. Please use a database instance instead.");
+    }
+    const session = this.session;
+    const query = session[isOneTimeQuery ? "prepareOneTimeQuery" : "prepareQuery"](this.dialect.sqlToQuery(this.getSQL()), orderSelectedFields(this.effectConfig.fields), "all", undefined, {
+      type: "select",
+      tables: [...this.usedTables]
+    }, this.cacheConfig);
+    query.joinsNotNullableMap = this.joinsNotNullableMap;
+    return query;
+  }
+  $withCache(config) {
+    this.cacheConfig = config === undefined ? { config: {}, enabled: true, autoInvalidate: true } : config === false ? { enabled: false } : { enabled: true, autoInvalidate: true, ...config };
+    return this;
+  }
+  prepare() {
+    return this._prepare(false);
+  }
+  run = (placeholderValues) => {
+    return this._prepare().run(placeholderValues);
+  };
+  all = (placeholderValues) => {
+    return this._prepare().all(placeholderValues);
+  };
+  get = (placeholderValues) => {
+    return this._prepare().get(placeholderValues);
+  };
+  values = (placeholderValues) => {
+    return this._prepare().values(placeholderValues);
+  };
+  execute = (placeholderValues) => {
+    return this._prepare().execute(placeholderValues);
+  };
+}
+applyEffectWrapper(SQLiteEffectSelectBase);
+
+export { SQLiteEffectSelectBuilder, SQLiteEffectSelectBase };

package/dist/chunks/permission-mya790jh.js

@@ -0,0 +1,72 @@
+import {
+  exports_agent
+} from "./permission-0c101nc9.js";
+import {
+  exports_schema
+} from "./permission-y8rs54ne.js";
+import {
+  exports_workspace
+} from "./permission-n6t016aw.js";
+import {
+  exports_model
+} from "./permission-xfd1xnk3.js";
+import {
+  exports_provider
+} from "./permission-d6vvk673.js";
+import {
+  exports_location
+} from "./permission-1e2ryyac.js";
+import {
+  exports_project
+} from "./permission-j2hktz7g.js";
+import {
+  AbsolutePath,
+  RelativePath
+} from "./permission-j07kk359.js";
+
+// src/session/info.ts
+import { DateTime, Schema } from "effect";
+import { PersistedRevert } from "@opencode-ai/schema/session-revert";
+import { Money } from "@opencode-ai/schema/money";
+var decodeRevert = Schema.decodeUnknownSync(PersistedRevert);
+function fromRow(row) {
+  return exports_schema.Info.make({
+    id: exports_schema.ID.make(row.id),
+    projectID: exports_project.ID.make(row.project_id),
+    title: row.title ?? undefined,
+    parentID: row.parent_id ? exports_schema.ID.make(row.parent_id) : undefined,
+    fork: row.fork_session_id && row.fork_boundary ? {
+      sessionID: exports_schema.ID.make(row.fork_session_id),
+      boundary: row.fork_boundary
+    } : undefined,
+    agent: row.agent ? exports_agent.ID.make(row.agent) : undefined,
+    model: row.model ? {
+      id: exports_model.ID.make(row.model.id),
+      providerID: exports_provider.ID.make(row.model.providerID),
+      variant: exports_model.VariantID.make(row.model.variant ?? "default")
+    } : undefined,
+    cost: Money.USD.make(row.cost),
+    tokens: {
+      input: row.tokens_input,
+      output: row.tokens_output,
+      reasoning: row.tokens_reasoning,
+      cache: {
+        read: row.tokens_cache_read,
+        write: row.tokens_cache_write
+      }
+    },
+    location: exports_location.Ref.make({
+      directory: AbsolutePath.make(row.directory),
+      workspaceID: row.workspace_id ? exports_workspace.ID.make(row.workspace_id) : undefined
+    }),
+    subpath: row.path ? RelativePath.make(row.path) : undefined,
+    revert: row.revert ? decodeRevert(row.revert) : undefined,
+    time: {
+      created: DateTime.makeUnsafe(row.time_created),
+      updated: DateTime.makeUnsafe(row.time_updated),
+      archived: row.time_archived ? DateTime.makeUnsafe(row.time_archived) : undefined
+    }
+  });
+}
+
+export { fromRow };

package/dist/chunks/permission-n3m50c2t.js

@@ -0,0 +1,15 @@
+// src/database/migration/20260309230000_move_org_to_state.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260309230000_move_org_to_state",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`account_state\` ADD \`active_org_id\` text;`);
+      yield* tx.run(`UPDATE \`account_state\` SET \`active_org_id\` = (SELECT \`selected_org_id\` FROM \`account\` WHERE \`account\`.\`id\` = \`account_state\`.\`active_account_id\`);`);
+      yield* tx.run(`ALTER TABLE \`account\` DROP COLUMN \`selected_org_id\`;`);
+    });
+  }
+};
+var _20260309230000_move_org_to_state_default = migration;
+
+export { _20260309230000_move_org_to_state_default };

package/dist/chunks/permission-n59ptmzm.js

@@ -0,0 +1,155 @@
+import {
+  exports_instructions as exports_instructions2
+} from "./permission-6v88ksgf.js";
+import {
+  exports_instruction_entry
+} from "./permission-c8dztf94.js";
+import {
+  exports_builtins
+} from "./permission-1cxqkg6x.js";
+import {
+  exports_instructions as exports_instructions4
+} from "./permission-b92sdcjk.js";
+import {
+  exports_mcp
+} from "./permission-06jas3ts.js";
+import {
+  exports_instructions as exports_instructions5
+} from "./permission-f6fn40ps.js";
+import {
+  exports_instructions as exports_instructions3
+} from "./permission-tyh0a1hs.js";
+import {
+  exports_supervisor
+} from "./permission-85wgk4kd.js";
+import {
+  exports_instruction_discovery
+} from "./permission-9rdqpzw3.js";
+import {
+  exports_model
+} from "./permission-14dbm5wf.js";
+import {
+  exports_tool
+} from "./permission-2qdvkq1m.js";
+import {
+  exports_store
+} from "./permission-2zyawa45.js";
+import {
+  exports_history
+} from "./permission-0cm1xtm8.js";
+import {
+  AgentNotFoundError
+} from "./permission-s6by3cc4.js";
+import {
+  exports_agent
+} from "./permission-0c101nc9.js";
+import {
+  exports_instructions
+} from "./permission-q4r4pzs4.js";
+import {
+  exports_location
+} from "./permission-1e2ryyac.js";
+import {
+  exports_database
+} from "./permission-8w2n8x74.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/session/context.ts
+var exports_context = {};
+__export(exports_context, {
+  node: () => node,
+  SessionContext: () => exports_context,
+  Service: () => Service
+});
+import { Context, Effect, Layer } from "effect";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+class Service extends Context.Service()("@opencode/SessionContext") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const agents = yield* exports_agent.Service;
+  const builtins = yield* exports_builtins.Service;
+  const db = (yield* exports_database.Service).db;
+  const discovery = yield* exports_instruction_discovery.Service;
+  const entries = yield* exports_instruction_entry.Service;
+  const location = yield* exports_location.Service;
+  const mcpInstructions = yield* exports_instructions4.Service;
+  const mcpTools = yield* exports_mcp.Service;
+  const models = yield* exports_model.Service;
+  const plugins = yield* exports_supervisor.Service;
+  const referenceInstructions = yield* exports_instructions2.Service;
+  const skillInstructions = yield* exports_instructions5.Service;
+  const store = yield* exports_store.Service;
+  const registry = yield* exports_tool.Service;
+  const select = Effect.fn("SessionContext.select")(function* (sessionID) {
+    const session = yield* store.get(sessionID);
+    if (!session)
+      return yield* Effect.die(new Error(`Session not found: ${sessionID}`));
+    if (session.location.directory !== location.directory || session.location.workspaceID !== location.workspaceID)
+      return yield* Effect.interrupt;
+    yield* plugins.flush;
+    yield* mcpTools.flush;
+    const agent = yield* agents.select(session.agent);
+    if (!agent.info)
+      return yield* new AgentNotFoundError({ sessionID: session.id, agent: session.agent ?? agent.id });
+    const loaded = yield* Effect.all({
+      tools: registry.snapshot(agent.info.permissions),
+      builtins: builtins.load(sessionID),
+      discovery: discovery.load(),
+      skills: skillInstructions.load(agent),
+      references: referenceInstructions.load(),
+      mcp: mcpInstructions.load(agent),
+      entries: entries.load(sessionID)
+    }, { concurrency: "unbounded" });
+    return {
+      session,
+      agent: { ...agent, info: agent.info },
+      instructions: exports_instructions.combine([
+        loaded.builtins,
+        exports_instructions3.make(loaded.tools.codeModeCatalog),
+        loaded.discovery,
+        loaded.skills,
+        loaded.references,
+        loaded.mcp,
+        loaded.entries
+      ]),
+      tools: loaded.tools
+    };
+  });
+  const load = Effect.fn("SessionContext.load")(function* (selection) {
+    const model = yield* models.resolve(selection.session);
+    const history = yield* exports_history.entriesForRunner(db, selection.session.id, selection.instructions);
+    return {
+      session: selection.session,
+      agent: selection.agent,
+      model,
+      initial: history.initial,
+      messages: history.entries.map((entry) => entry.message),
+      tools: selection.tools
+    };
+  });
+  return Service.of({ select, load });
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [
+    exports_agent.node,
+    exports_database.node,
+    exports_builtins.node,
+    exports_instruction_discovery.node,
+    exports_instruction_entry.node,
+    exports_location.node,
+    exports_instructions4.node,
+    exports_mcp.node,
+    exports_supervisor.node,
+    exports_instructions2.node,
+    exports_model.node,
+    exports_store.node,
+    exports_instructions5.node,
+    exports_tool.node
+  ]
+});
+
+export { Service, node, exports_context };

package/dist/chunks/permission-n6t016aw.js

@@ -0,0 +1,153 @@
+import {
+  exports_driver
+} from "./permission-tdm3rp2k.js";
+import {
+  WorkspaceTable
+} from "./permission-3c4nztf9.js";
+import {
+  exports_database
+} from "./permission-8w2n8x74.js";
+import {
+  exports_keyed_mutex
+} from "./permission-0kvmztkf.js";
+import {
+  __export
+} from "./permission-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 };