@opencode-ai/core 0.0.0-beta-18600 → 0.0.0-beta-18684

package/dist/chunks/state-qzp632xx.js

@@ -0,0 +1,483 @@
+import {
+  exports_generate
+} from "./state-xgv25zxy.js";
+import {
+  exports_projector
+} from "./state-5t7q56hh.js";
+import {
+  exports_instruction_entry
+} from "./state-cnsekzdm.js";
+import {
+  exports_session
+} from "./state-rw00p5qk.js";
+import {
+  exports_execution
+} from "./state-zmwyjx4d.js";
+import {
+  exports_inbox
+} from "./state-pbrq9pmc.js";
+import {
+  exports_model_transport
+} from "./state-tjrfm0xh.js";
+import {
+  exports_supervisor_service
+} from "./state-s33fw6zm.js";
+import {
+  Slug
+} from "./state-df3v2q6j.js";
+import {
+  exports_job
+} from "./state-np2sgr2t.js";
+import {
+  exports_environment
+} from "./state-6ky7rqk7.js";
+import {
+  exports_app
+} from "./state-50jxp3hw.js";
+import {
+  exports_skill
+} from "./state-sz7acswn.js";
+import {
+  exports_command
+} from "./state-vwj18m7v.js";
+import {
+  exports_location_service_map
+} from "./state-zdkg1k91.js";
+import {
+  exports_store
+} from "./state-tfd8n8cn.js";
+import {
+  exports_history
+} from "./state-v16fefw3.js";
+import {
+  fromRow
+} from "./state-264e1nfp.js";
+import {
+  AttachmentError,
+  BusyError,
+  CompactionConflictError,
+  ForkEmptyError,
+  InboxConflictError,
+  MessageDecodeError,
+  MessageIncompleteError,
+  MessageNotAssistantError,
+  MessageNotFoundError,
+  MessageToolIncompleteError,
+  NotFoundError,
+  PromptConflictError,
+  SkillNotFoundError,
+  SyntheticConflictError
+} from "./state-cgqn2mrm.js";
+import {
+  exports_instruction_state
+} from "./state-hxcd35r2.js";
+import {
+  SessionMessageTable,
+  SessionTable
+} from "./state-q606pcse.js";
+import {
+  SessionMessage
+} from "./state-8rpfd2h6.js";
+import {
+  ID,
+  Info,
+  SessionSchema
+} from "./state-bjwj8hwv.js";
+import {
+  SessionEvent
+} from "./state-a83yvq99.js";
+import {
+  exports_location
+} from "./state-qph0wk53.js";
+import {
+  exports_project
+} from "./state-x9782t8s.js";
+import {
+  AbsolutePath,
+  PositiveInt,
+  RelativePath
+} from "./state-j07kk359.js";
+import {
+  exports_bus
+} from "./state-cgy4zpa6.js";
+import {
+  exports_database
+} from "./state-vpac0x8g.js";
+import {
+  __export
+} from "./state-rvfvac9x.js";
+
+// src/session.ts
+var exports_session2 = {};
+__export(exports_session2, {
+  node: () => node,
+  SyntheticConflictError: () => SyntheticConflictError,
+  SkillNotFoundError: () => SkillNotFoundError,
+  SessionSchema: () => SessionSchema,
+  Session: () => exports_session2,
+  Service: () => Service,
+  PromptConflictError: () => PromptConflictError,
+  NotFoundError: () => NotFoundError,
+  MessageToolIncompleteError: () => MessageToolIncompleteError,
+  MessageNotFoundError: () => MessageNotFoundError,
+  MessageNotAssistantError: () => MessageNotAssistantError,
+  MessageIncompleteError: () => MessageIncompleteError,
+  MessageDecodeError: () => MessageDecodeError,
+  ListInput: () => ListInput,
+  ListAnchor: () => ListAnchor,
+  Info: () => Info,
+  InboxConflictError: () => InboxConflictError,
+  ID: () => ID,
+  DestinationUnavailableError: () => DestinationUnavailableError,
+  DestinationNotFoundError: () => DestinationNotFoundError,
+  DestinationNotDirectoryError: () => DestinationNotDirectoryError,
+  CompactionConflictError: () => CompactionConflictError,
+  BusyError: () => BusyError,
+  AttachmentError: () => AttachmentError
+});
+import { Cause, Effect, Layer, Schema, Context, RcMap, Stream, Scope } from "effect";
+import { ListAnchor } from "@opencode-ai/schema/session";
+import { and, asc, desc, eq, gt, isNull, like, lt, or } from "drizzle-orm";
+import { Workspace } from "@opencode-ai/schema/workspace";
+import { Model } from "@opencode-ai/schema/model";
+import path from "path";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Event } from "@opencode-ai/schema/event";
+import { Global } from "@opencode-ai/util/global";
+var ListInputBase = {
+  workspaceID: Workspace.ID.pipe(Schema.optional),
+  search: Schema.String.pipe(Schema.optional),
+  limit: PositiveInt.pipe(Schema.optional),
+  order: Schema.Literals(["asc", "desc"]).pipe(Schema.optional),
+  parentID: Schema.NullOr(SessionSchema.ID).pipe(Schema.optional),
+  anchor: ListAnchor.pipe(Schema.optional)
+};
+var ListDirectoryInput = Schema.Struct({
+  ...ListInputBase,
+  directory: AbsolutePath
+});
+var ListProjectInput = Schema.Struct({
+  ...ListInputBase,
+  project: exports_project.ID,
+  subpath: RelativePath.pipe(Schema.optional)
+});
+var ListAllInput = Schema.Struct(ListInputBase);
+var ListInput = Schema.Union([ListDirectoryInput, ListProjectInput, ListAllInput]);
+class DestinationNotFoundError extends Schema.TaggedError()("Session.DestinationNotFoundError", { directory: AbsolutePath }) {
+}
+
+class DestinationNotDirectoryError extends Schema.TaggedError()("Session.DestinationNotDirectoryError", { directory: AbsolutePath }) {
+}
+
+class DestinationUnavailableError extends Schema.TaggedError()("Session.DestinationUnavailableError", { directory: AbsolutePath }) {
+}
+
+class Service extends Context.Service()("@opencode/Session") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const app = yield* exports_app.Metadata;
+  const database = yield* exports_database.Service;
+  const db = database.db;
+  const bus = yield* exports_bus.Service;
+  const projects = yield* exports_project.Service;
+  const global = yield* Global.Service;
+  const execution = yield* exports_execution.Service;
+  const store = yield* exports_store.Service;
+  const locations = yield* exports_location_service_map.Service;
+  const fs = yield* FSUtil.Service;
+  const jobs = yield* exports_job.Service;
+  const environments = yield* exports_environment.Service;
+  const scope = yield* Scope.Scope;
+  const sessions = yield* exports_session.make((ref) => locations.get(ref));
+  const admission = yield* exports_inbox.Service;
+  const closeTransport = Effect.fn("Session.closeTransport")(function* (session) {
+    const location = exports_location.Ref.make({
+      directory: session.location.directory,
+      workspaceID: session.location.workspaceID
+    });
+    if (!(yield* RcMap.has(locations.rcMap, location)))
+      return;
+    yield* exports_model_transport.Service.use((transport) => transport.close(session.id)).pipe(Effect.provide(locations.get(location)));
+  });
+  const isDurableSessionEvent = Schema.is(SessionEvent.Durable);
+  const result = Service.of({
+    create: Effect.fn("Session.create")(function* (input) {
+      const sessionID = input.id ?? SessionSchema.ID.create();
+      const recorded = yield* store.get(sessionID);
+      if (recorded)
+        return recorded;
+      const parent = input.parentID ? yield* store.get(input.parentID) : undefined;
+      if (input.parentID && parent === undefined)
+        return yield* new NotFoundError({ sessionID: input.parentID });
+      const location = parent?.location ?? input.location;
+      if (location === undefined)
+        return yield* Effect.die(new Error("Session.create requires either location or an existing parentID"));
+      const project = yield* projects.resolve(location.directory);
+      const projected = yield* bus.publish(SessionEvent.Created, {
+        sessionID,
+        slug: Slug.create(),
+        version: app.version,
+        projectID: project.id,
+        parentID: input.parentID,
+        location,
+        subpath: RelativePath.make(path.relative(project.directory, location.directory).replaceAll("\\", "/")),
+        title: input.title,
+        agent: input.agent,
+        metadata: input.metadata ?? parent?.metadata,
+        model: input.model ? {
+          id: Model.ID.make(input.model.id),
+          providerID: input.model.providerID,
+          variant: input.model.variant
+        } : undefined
+      }, { location }).pipe(Effect.as({ type: "created" }), Effect.catchDefect((defect) => {
+        if (!(defect instanceof exports_projector.SessionAlreadyProjected)) {
+          return Effect.die(defect);
+        }
+        return store.get(sessionID).pipe(Effect.flatMap((session) => session ? Effect.succeed({ type: "existing", session }) : Effect.die(defect)));
+      }));
+      if (projected.type === "existing")
+        return projected.session;
+      return yield* result.get(sessionID).pipe(Effect.orDie);
+    }),
+    fork: Effect.fn("Session.fork")(function* (input) {
+      const parent = yield* result.get(input.sessionID);
+      const boundary = yield* db.select({ id: SessionMessageTable.id }).from(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, input.sessionID), input.boundary.type === "before" ? eq(SessionMessageTable.id, input.boundary.messageID) : undefined)).orderBy(desc(SessionMessageTable.seq)).limit(1).get().pipe(Effect.orDie);
+      if (!boundary && input.boundary.type === "before")
+        return yield* new MessageNotFoundError({
+          sessionID: input.sessionID,
+          messageID: input.boundary.messageID
+        });
+      if (!boundary)
+        return yield* new ForkEmptyError({ sessionID: input.sessionID });
+      const sessionID = SessionSchema.ID.create();
+      const inherited = yield* db.transaction(() => Effect.all({
+        instructions: exports_instruction_state.current(db, parent.id),
+        instructionEntries: exports_instruction_entry.snapshot(db, parent.id)
+      })).pipe(Effect.orDie);
+      yield* bus.publish(SessionEvent.Forked, {
+        sessionID,
+        parentID: parent.id,
+        boundary: { ...input.boundary, messageID: boundary.id },
+        ...inherited
+      });
+      return yield* result.get(sessionID).pipe(Effect.orDie);
+    }),
+    get: (sessionID) => sessions.forSession(sessionID).get(),
+    environment: Effect.fn("Session.environment")(function* (input) {
+      yield* result.get(input.sessionID);
+      if (input.variables !== undefined)
+        yield* environments.set(input.sessionID, input.variables);
+      return yield* environments.get(input.sessionID);
+    }),
+    view: (input) => sessions.forSession(input.sessionID).view(input),
+    remove: Effect.fn("Session.remove")(function* (sessionID) {
+      const session = yield* result.get(sessionID);
+      yield* execution.interrupt(sessionID);
+      yield* execution.awaitIdle(sessionID);
+      yield* closeTransport(session);
+      const children = yield* result.list({ parentID: sessionID });
+      yield* Effect.forEach(children.data, (child) => result.remove(child.id), { concurrency: 1, discard: true });
+      yield* environments.clear(sessionID);
+      yield* bus.publish(SessionEvent.Deleted, { sessionID });
+      yield* bus.remove(sessionID);
+    }),
+    list: Effect.fn("Session.list")(function* (input = {}) {
+      const direction = input.anchor?.direction ?? "next";
+      const requestedOrder = input.order ?? "desc";
+      const order = direction === "previous" ? requestedOrder === "asc" ? "desc" : "asc" : requestedOrder;
+      const sortColumn = SessionTable.time_updated;
+      const conditions = [];
+      if ("directory" in input)
+        conditions.push(eq(SessionTable.directory, input.directory));
+      if (input.workspaceID)
+        conditions.push(eq(SessionTable.workspace_id, input.workspaceID));
+      if ("project" in input)
+        conditions.push(eq(SessionTable.project_id, input.project));
+      if ("project" in input && input.subpath !== undefined)
+        conditions.push(eq(SessionTable.path, input.subpath));
+      if (input.search)
+        conditions.push(like(SessionTable.title, `%${input.search}%`));
+      if (input.parentID !== undefined)
+        conditions.push(input.parentID === null ? isNull(SessionTable.parent_id) : eq(SessionTable.parent_id, input.parentID));
+      if (input.anchor) {
+        conditions.push(order === "asc" ? or(gt(sortColumn, input.anchor.time), and(eq(sortColumn, input.anchor.time), gt(SessionTable.id, input.anchor.id))) : or(lt(sortColumn, input.anchor.time), and(eq(sortColumn, input.anchor.time), lt(SessionTable.id, input.anchor.id))));
+      }
+      const query = db.select().from(SessionTable).where(conditions.length > 0 ? and(...conditions) : undefined).orderBy(order === "asc" ? asc(sortColumn) : desc(sortColumn), order === "asc" ? asc(SessionTable.id) : desc(SessionTable.id));
+      const rows = yield* (input.limit === undefined ? query.all() : query.limit(input.limit).all()).pipe(Effect.orDie);
+      return { data: (direction === "previous" ? rows.toReversed() : rows).map((row) => fromRow(row)) };
+    }),
+    messages: Effect.fn("Session.messages")(function* (input) {
+      yield* result.get(input.sessionID);
+      const direction = input.cursor?.direction ?? "next";
+      const requestedOrder = input.order ?? "desc";
+      const order = direction === "previous" ? requestedOrder === "asc" ? "desc" : "asc" : requestedOrder;
+      const anchor = input.cursor ? yield* db.select({ seq: SessionMessageTable.seq }).from(SessionMessageTable).where(and(eq(SessionMessageTable.session_id, input.sessionID), eq(SessionMessageTable.id, input.cursor.id))).get().pipe(Effect.orDie) : undefined;
+      if (input.cursor && !anchor)
+        return [];
+      const boundary = anchor ? order === "asc" ? gt(SessionMessageTable.seq, anchor.seq) : lt(SessionMessageTable.seq, anchor.seq) : undefined;
+      const where = boundary ? and(eq(SessionMessageTable.session_id, input.sessionID), boundary) : eq(SessionMessageTable.session_id, input.sessionID);
+      const query = db.select().from(SessionMessageTable).where(where).orderBy(order === "asc" ? asc(SessionMessageTable.seq) : desc(SessionMessageTable.seq));
+      const rows = yield* (input.limit === undefined ? query.all() : query.limit(input.limit).all()).pipe(Effect.orDie);
+      return yield* Effect.forEach(direction === "previous" ? rows.toReversed() : rows, exports_history.decodeMessageRow);
+    }),
+    message: (input) => sessions.forSession(input.sessionID).message(input.messageID),
+    updateMessage: (input) => sessions.forSession(input.sessionID).updateMessage(input),
+    context: Effect.fn("Session.context")(function* (sessionID) {
+      yield* result.get(sessionID);
+      return yield* store.context(sessionID);
+    }),
+    inbox: (sessionID) => sessions.forSession(sessionID).inbox(),
+    cancelInbox: (input) => sessions.forSession(input.sessionID).cancelInbox(input.inboxID),
+    steerInbox: (input) => sessions.forSession(input.sessionID).steerInbox(input.inboxID),
+    queueInbox: (input) => sessions.forSession(input.sessionID).queueInbox(input.inboxID),
+    log: (input) => Stream.unwrap(result.get(input.sessionID).pipe(Effect.as(bus.log({ aggregateID: input.sessionID, after: input.after, follow: input.follow })))).pipe(Stream.filter((item) => exports_bus.isSynced(item) || isDurableSessionEvent(item))),
+    prompt: (input) => sessions.forSession(input.sessionID).prompt(input),
+    generate: Effect.fn("Session.generate")(function* (input) {
+      const session = yield* result.get(input.sessionID);
+      const generate = yield* exports_generate.Service.pipe(Effect.provide(locations.get(session.location)));
+      return yield* generate.generate(input);
+    }),
+    command: Effect.fn("Session.command")(function* (input) {
+      const session = yield* result.get(input.sessionID);
+      const commands = yield* Effect.gen(function* () {
+        const plugins = yield* exports_supervisor_service.Service;
+        yield* plugins.flush;
+        return yield* exports_command.Service;
+      }).pipe(Effect.provide(locations.get(session.location)));
+      const delivery = input.delivery ?? "steer";
+      yield* commands.execute({
+        name: input.command,
+        invocation: {
+          sessionID: input.sessionID,
+          prompt: {
+            text: input.text,
+            files: input.files,
+            agents: input.agents,
+            skills: input.skills
+          },
+          delivery
+        }
+      });
+    }),
+    shell: (input) => sessions.forSession(input.sessionID).shell(input),
+    skill: Effect.fn("Session.skill")(function* (input) {
+      const session = yield* result.get(input.sessionID);
+      const skills = yield* exports_skill.Service.pipe(Effect.provide(locations.get(session.location)));
+      const skill = yield* skills.get(input.skill);
+      if (!skill)
+        return yield* new SkillNotFoundError({ skill: input.skill });
+      yield* bus.publish(SessionEvent.Skill.Activated, {
+        sessionID: input.sessionID,
+        id: skill.id,
+        name: skill.name,
+        text: skill.content
+      }, { id: input.id ? Event.ID.make(input.id.replace(/^msg_/, "evt_")) : undefined });
+      if (input.resume !== false)
+        yield* execution.resume(input.sessionID).pipe(Effect.ignore, Effect.forkIn(scope, { startImmediately: true }), Effect.asVoid);
+    }),
+    switchAgent: (input) => sessions.forSession(input.sessionID).switchAgent(input),
+    switchModel: (input) => sessions.forSession(input.sessionID).switchModel(input),
+    rename: (input) => sessions.forSession(input.sessionID).rename(input),
+    move: Effect.fn("Session.move")(function* (input) {
+      const current = yield* result.get(input.sessionID);
+      const value = input.directory.trim();
+      const expanded = value === "~" ? global.home : value.startsWith("~/") ? path.join(global.home, value.slice(2)) : value;
+      const directory = AbsolutePath.make(path.resolve(current.location.directory, expanded));
+      const info = yield* fs.stat(directory).pipe(Effect.orElseSucceed(() => {
+        return;
+      }));
+      if (!info)
+        return yield* new DestinationNotFoundError({ directory });
+      if (info.type !== "Directory")
+        return yield* new DestinationNotDirectoryError({ directory });
+      const project = yield* projects.resolve(directory);
+      const payload = {
+        location: exports_location.Ref.make({ directory, workspaceID: input.workspaceID }),
+        projectID: project.id,
+        subpath: RelativePath.make(path.relative(project.directory, directory).replaceAll("\\", "/"))
+      };
+      yield* exports_location.Service.pipe(Effect.provide(locations.get(payload.location)), Effect.scoped, Effect.catchCause((cause) => {
+        if (Cause.hasInterruptsOnly(cause))
+          return Effect.failCause(cause);
+        return Effect.logWarning("session move destination unavailable", { directory, cause }).pipe(Effect.andThen(Effect.fail(new DestinationUnavailableError({ directory }))));
+      }));
+      const item = exports_inbox.Item.make({
+        type: "move",
+        payload,
+        delivery: input.delivery ?? "steer"
+      });
+      yield* exports_inbox.serialized(input.sessionID, Effect.gen(function* () {
+        const latest = yield* result.get(input.sessionID);
+        const source = yield* fs.stat(latest.location.directory).pipe(Effect.orElseSucceed(() => {
+          return;
+        }));
+        if (!source || source.type !== "Directory") {
+          const cancellations = (yield* exports_inbox.moveIDs(db, input.sessionID)).map((item2) => [SessionEvent.InboxCancelled, { sessionID: input.sessionID, inboxID: item2.id }]);
+          const moved = [SessionEvent.Moved, { sessionID: input.sessionID, ...payload }];
+          const first = cancellations[0];
+          if (!first)
+            return yield* bus.publish(...moved).pipe(Effect.asVoid);
+          return yield* bus.publishAll([first, ...cancellations.slice(1), moved]);
+        }
+        yield* admission.admit({
+          id: SessionMessage.ID.create(),
+          sessionID: input.sessionID,
+          item
+        }).pipe(Effect.orDie);
+      }));
+      yield* execution.wake(input.sessionID);
+    }),
+    compact: (input) => sessions.forSession(input.sessionID).compact(input),
+    wait: (sessionID) => sessions.forSession(sessionID).wait(),
+    active: execution.active,
+    background: Effect.fn("Session.background")(function* (sessionID) {
+      yield* result.get(sessionID);
+      const backgrounded = yield* jobs.backgroundAll({ sessionID });
+      if (backgrounded.length === 0)
+        return;
+      yield* result.synthetic({
+        sessionID,
+        text: [
+          "User requested that active blocking work be moved to the background.",
+          "",
+          "Backgrounded work:",
+          ...backgrounded.map((job) => `- ${job.type}: ${job.title && job.title.length > 0 ? job.title : job.id}`),
+          "",
+          "The backgrounded work is still unfinished. Move on to other work if you can. If there is nothing else useful to do, finish your response. Do not wait, sleep, poll, or report the backgrounded work as complete until a later completion notification is added to the conversation."
+        ].join(`
+`)
+      }).pipe(Effect.catchTag("Session.SyntheticConflictError", Effect.die));
+    }),
+    resume: (sessionID) => sessions.forSession(sessionID).resume(),
+    synthetic: (input) => sessions.forSession(input.sessionID).synthetic(input),
+    interrupt: (sessionID, options) => sessions.forSession(sessionID).interrupt(options),
+    revert: {
+      stage: (input) => sessions.forSession(input.sessionID).revert.stage(input),
+      clear: (sessionID) => sessions.forSession(sessionID).revert.clear(),
+      commit: (sessionID) => sessions.forSession(sessionID).revert.commit()
+    }
+  });
+  return result;
+}));
+var node = makeGlobalNode({
+  service: Service,
+  layer,
+  deps: [
+    exports_job.node,
+    exports_environment.node,
+    exports_database.node,
+    exports_bus.node,
+    exports_project.node,
+    exports_execution.node,
+    exports_store.node,
+    exports_inbox.node,
+    exports_location_service_map.node,
+    exports_projector.node,
+    FSUtil.node,
+    Global.node,
+    exports_app.node
+  ]
+});
+
+export { ListAnchor, ListInput, DestinationNotFoundError, DestinationNotDirectoryError, DestinationUnavailableError, Service, node, exports_session2 as exports_session };

package/dist/chunks/{project-r13w8t0w.js → state-r13w8t0w.js}

@@ -1,9 +1,9 @@
 import {
   exports_provider
-} from "./project-krsqcmnj.js";
+} from "./state-krsqcmnj.js";
 import {
   __export
-} from "./project-rvfvac9x.js";
+} from "./state-rvfvac9x.js";
 
 // src/model.ts
 var exports_model = {};

package/dist/chunks/{project-r3k9abhd.js → state-r3k9abhd.js}

@@ -1,9 +1,9 @@
 import {
   PositiveInt
-} from "./project-j07kk359.js";
+} from "./state-j07kk359.js";
 import {
   __export
-} from "./project-rvfvac9x.js";
+} from "./state-rvfvac9x.js";
 
 // src/v1/config/attachment.ts
 var exports_attachment = {};

package/dist/chunks/{project-r9d3d23r.js → state-r9d3d23r.js}

@@ -1,6 +1,6 @@
 import {
   which
-} from "./project-k3e42drn.js";
+} from "./state-k3e42drn.js";
 
 // src/formatter/builtins.ts
 import { Effect } from "effect";

package/dist/chunks/{project-rahat93a.js → state-rahat93a.js}

@@ -1,6 +1,6 @@
 import {
   which
-} from "./project-k3e42drn.js";
+} from "./state-k3e42drn.js";
 
 // src/ripgrep/binary.ts
 import path from "path";

package/dist/chunks/{project-rbnp2c85.js → state-rbnp2c85.js}

@@ -1,12 +1,12 @@
 import {
   exports_model
-} from "./project-r13w8t0w.js";
+} from "./state-r13w8t0w.js";
 import {
   exports_provider
-} from "./project-krsqcmnj.js";
+} from "./state-krsqcmnj.js";
 import {
   __export
-} from "./project-rvfvac9x.js";
+} from "./state-rvfvac9x.js";
 
 // src/github-copilot/models.ts
 var exports_models = {};

package/dist/chunks/{project-cz0kv403.js → state-rf120rew.js}

@@ -1,15 +1,15 @@
 import {
   exports_entry_observer
-} from "./project-kp1t5rcy.js";
-import {
-  exports_wildcard
-} from "./project-y67x6rf6.js";
+} from "./state-kp1t5rcy.js";
 import {
   exports_config
-} from "./project-6kmefejb.js";
+} from "./state-rrqrf7hs.js";
+import {
+  exports_wildcard
+} from "./state-y67x6rf6.js";
 import {
   __export
-} from "./project-rvfvac9x.js";
+} from "./state-rvfvac9x.js";
 
 // src/config/plugin/policy.ts
 var exports_policy = {};

package/dist/chunks/{project-sg39537v.js → state-rg042c41.js}

@@ -1,18 +1,18 @@
 import {
   exports_location
-} from "./project-pm12wdxj.js";
+} from "./state-qph0wk53.js";
 import {
   exports_project
-} from "./project-cg0y8hn9.js";
+} from "./state-x9782t8s.js";
 import {
   exports_markers
-} from "./project-eygmcrvz.js";
+} from "./state-cp8v16sk.js";
 import {
   AbsolutePath
-} from "./project-j07kk359.js";
+} from "./state-j07kk359.js";
 import {
   __export
-} from "./project-rvfvac9x.js";
+} from "./state-rvfvac9x.js";
 
 // src/location-mutation.ts
 var exports_location_mutation = {};

package/dist/chunks/{project-ntzp27rn.js → state-rg5dm0vs.js}

@@ -1,15 +1,12 @@
 import {
   PermissionTable
-} from "./project-d4h7vwhh.js";
-import {
-  exports_project
-} from "./project-cg0y8hn9.js";
+} from "./state-d4h7vwhh.js";
 import {
   exports_database
-} from "./project-gcc0jgqv.js";
+} from "./state-vpac0x8g.js";
 import {
   __export
-} from "./project-rvfvac9x.js";
+} from "./state-rvfvac9x.js";
 
 // src/permission/saved.ts
 var exports_saved = {};
@@ -24,15 +21,16 @@ __export(exports_saved, {
 });
 import { eq } from "drizzle-orm";
 import { Context, Effect, Layer, Schema } from "effect";
+import { Project } from "@opencode-ai/schema/project";
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
 import { PermissionSaved } from "@opencode-ai/schema/permission-saved";
 var ID = PermissionSaved.ID;
 var Info = PermissionSaved.Info;
 var ListInput = Schema.Struct({
-  projectID: exports_project.ID.pipe(Schema.optional)
+  projectID: Project.ID.pipe(Schema.optional)
 }).annotate({ identifier: "PermissionSaved.ListInput" });
 var AddInput = Schema.Struct({
-  projectID: exports_project.ID,
+  projectID: Project.ID,
   action: Schema.String,
   resources: Schema.Array(Schema.String)
 }).annotate({ identifier: "PermissionSaved.AddInput" });

package/dist/chunks/{project-z1at3hn2.js → state-rjawwthv.js}

@@ -1,18 +1,18 @@
 import {
   exports_store
-} from "./project-vjmn5wwb.js";
+} from "./state-tfd8n8cn.js";
 import {
   SessionEvent
-} from "./project-a83yvq99.js";
+} from "./state-a83yvq99.js";
 import {
   exports_location
-} from "./project-pm12wdxj.js";
+} from "./state-qph0wk53.js";
 import {
   exports_bus
-} from "./project-gy9zm4ck.js";
+} from "./state-cgy4zpa6.js";
 import {
   __export
-} from "./project-rvfvac9x.js";
+} from "./state-rvfvac9x.js";
 
 // src/session/instructions.ts
 var exports_instructions = {};