@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-zfxc0ze5.js

@@ -0,0 +1,123 @@
+import {
+  getTableColumnsRuntime,
+  getTableLikeName,
+  getViewSelectedFieldsRuntime,
+  mapUpdateSet,
+  orderSelectedFields
+} from "./permission-ma07p6tt.js";
+
+// src/database/drizzle/sqlite-core/effect/update.ts
+import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";
+import { entityKind, is } from "drizzle-orm/entity";
+import { SelectionProxyHandler } from "drizzle-orm/selection-proxy";
+import { SQLiteTable } from "drizzle-orm/sqlite-core/table";
+import { extractUsedTable } from "drizzle-orm/sqlite-core/utils";
+import { SQLiteViewBase } from "drizzle-orm/sqlite-core/view-base";
+import { Subquery } from "drizzle-orm/subquery";
+class SQLiteEffectUpdateBuilder {
+  table;
+  session;
+  dialect;
+  withList;
+  static [entityKind] = "SQLiteEffectUpdateBuilder";
+  constructor(table, session, dialect, withList) {
+    this.table = table;
+    this.session = session;
+    this.dialect = dialect;
+    this.withList = withList;
+  }
+  set(values) {
+    return new SQLiteEffectUpdateBase(this.table, mapUpdateSet(this.table, values), this.session, this.dialect, this.withList);
+  }
+}
+
+class SQLiteEffectUpdateBase {
+  effectSession;
+  effectDialect;
+  static [entityKind] = "SQLiteEffectUpdate";
+  config;
+  constructor(table, set, effectSession, effectDialect, withList) {
+    this.effectSession = effectSession;
+    this.effectDialect = effectDialect;
+    this.config = { set, table, withList, joins: [] };
+  }
+  from(source) {
+    this.config.from = source;
+    return this;
+  }
+  createJoin(joinType) {
+    return (table, on) => {
+      const tableName = getTableLikeName(table);
+      if (typeof tableName === "string" && this.config.joins.some((join) => join.alias === tableName)) {
+        throw new Error(`Alias "${tableName}" is already used in this query`);
+      }
+      if (typeof on === "function") {
+        const from = this.config.from ? is(table, SQLiteTable) ? getTableColumnsRuntime(table) : is(table, Subquery) ? table._.selectedFields : is(table, SQLiteViewBase) ? getViewSelectedFieldsRuntime(table).selectedFields : undefined : undefined;
+        on = on(new Proxy(this.config.table._.columns, new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })), from && new Proxy(from, new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })));
+      }
+      this.config.joins.push({ on, table, joinType, alias: tableName });
+      return this;
+    };
+  }
+  leftJoin = this.createJoin("left");
+  rightJoin = this.createJoin("right");
+  innerJoin = this.createJoin("inner");
+  fullJoin = this.createJoin("full");
+  where(where) {
+    this.config.where = where;
+    return this;
+  }
+  orderBy(...columns) {
+    if (typeof columns[0] === "function") {
+      const orderBy = columns[0](new Proxy(getTableColumnsRuntime(this.config.table), new SelectionProxyHandler({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })));
+      this.config.orderBy = Array.isArray(orderBy) ? orderBy : [orderBy];
+      return this;
+    }
+    this.config.orderBy = columns;
+    return this;
+  }
+  limit(limit) {
+    this.config.limit = limit;
+    return this;
+  }
+  returning(fields = getTableColumnsRuntime(this.config.table)) {
+    this.config.returning = orderSelectedFields(fields);
+    return this;
+  }
+  getSQL() {
+    return this.effectDialect.buildUpdateQuery(this.config);
+  }
+  toSQL() {
+    return this.effectDialect.sqlToQuery(this.getSQL());
+  }
+  _prepare(isOneTimeQuery = true) {
+    return this.effectSession[isOneTimeQuery ? "prepareOneTimeQuery" : "prepareQuery"](this.effectDialect.sqlToQuery(this.getSQL()), this.config.returning, this.config.returning ? "all" : "run", undefined, {
+      type: "update",
+      tables: extractUsedTable(this.config.table)
+    });
+  }
+  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);
+  };
+  $dynamic() {
+    return this;
+  }
+}
+applyEffectWrapper(SQLiteEffectUpdateBase);
+
+export { SQLiteEffectUpdateBuilder, SQLiteEffectUpdateBase };

package/dist/chunks/permission-zr271bqv.js

@@ -0,0 +1,103 @@
+import {
+  exports_permission
+} from "./permission-qa8qg9jd.js";
+import {
+  exports_bus
+} from "./permission-r5ce0emk.js";
+import {
+  exports_state
+} from "./permission-wt193r4g.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/skill.ts
+var exports_skill = {};
+__export(exports_skill, {
+  toModelOutput: () => toModelOutput,
+  node: () => node,
+  available: () => available,
+  UrlSource: () => UrlSource,
+  Source: () => Source,
+  Skill: () => exports_skill,
+  Service: () => Service,
+  Name: () => Name,
+  Info: () => Info,
+  ID: () => ID,
+  Event: () => Event,
+  EmbeddedSource: () => EmbeddedSource,
+  DirectorySource: () => DirectorySource
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import path from "path";
+import { Context, Effect, Layer } from "effect";
+import { Skill } from "@opencode-ai/schema/skill";
+import { Event } from "@opencode-ai/schema/skill";
+var DirectorySource = Skill.DirectorySource;
+var UrlSource = Skill.UrlSource;
+var EmbeddedSource = Skill.EmbeddedSource;
+var Source = Skill.Source;
+var Info = Skill.Info;
+var ID = Skill.ID;
+var Name = Skill.Name;
+var available = (skills, agent) => skills.filter((skill) => exports_permission.evaluate("skill", skill.id, agent.permissions).effect !== "deny");
+var toModelOutput = (skill, files) => {
+  const directory = path.dirname(skill.location);
+  return [
+    `<skill_content name="${skill.name}">`,
+    `# Skill: ${skill.name}`,
+    "",
+    skill.content.trim(),
+    "",
+    `Base directory for this skill: ${directory}`,
+    "Relative paths in this skill (e.g., scripts/, reference/) are relative to this base directory.",
+    "Note: file list is sampled.",
+    "",
+    "<skill_files>",
+    ...files.map((file) => `<file>${file}</file>`),
+    "</skill_files>",
+    "</skill_content>"
+  ].join(`
+`);
+};
+
+class Service extends Context.Service()("@opencode/Skill") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const bus = yield* exports_bus.Service;
+  const state = exports_state.create({
+    name: "skill",
+    initial: () => ({ skills: new Map }),
+    draft: (draft) => ({
+      list: () => Array.from(draft.skills.values()),
+      add: (skill) => {
+        draft.skills.set(skill.id, { ...skill });
+      },
+      update: (id, update) => {
+        const current = draft.skills.get(ID.make(id));
+        if (!current)
+          return;
+        update(current);
+        current.id = ID.make(id);
+      },
+      remove: (id) => {
+        draft.skills.delete(ID.make(id));
+      }
+    }),
+    finalize: () => bus.publish(Skill.Event.Updated, {}).pipe(Effect.asVoid)
+  });
+  return Service.of({
+    transform: state.transform,
+    reload: state.reload,
+    list: Effect.fn("Skill.list")(function* () {
+      return Array.from(state.get().skills.values());
+    })
+  });
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [exports_bus.node]
+});
+
+export { DirectorySource, UrlSource, EmbeddedSource, Source, Info, ID, Name, available, toModelOutput, Service, node, exports_skill, Event };

package/dist/chunks/permission-zsf8rs93.js

@@ -0,0 +1,20 @@
+// src/event/sql.ts
+import { sqliteTable, text, integer, index, uniqueIndex } from "drizzle-orm/sqlite-core";
+var EventSequenceTable = sqliteTable("event_sequence", {
+  aggregate_id: text().notNull().primaryKey(),
+  seq: integer().notNull(),
+  owner_id: text()
+});
+var EventTable = sqliteTable("event", {
+  id: text().$type().primaryKey(),
+  aggregate_id: text().notNull().references(() => EventSequenceTable.aggregate_id, { onDelete: "cascade" }),
+  seq: integer().notNull(),
+  created: integer().notNull().default(0),
+  type: text().notNull(),
+  data: text({ mode: "json" }).$type().notNull()
+}, (table) => [
+  uniqueIndex("event_aggregate_seq_idx").on(table.aggregate_id, table.seq),
+  index("event_aggregate_type_seq_idx").on(table.aggregate_id, table.type, table.seq)
+]);
+
+export { EventSequenceTable, EventTable };

package/dist/chunks/permission-zt25ybqs.js

@@ -0,0 +1,370 @@
+import {
+  exports_prompt_cache_key
+} from "./permission-52jzav25.js";
+import {
+  exports_usage
+} from "./permission-8ywqk2j9.js";
+import {
+  exports_model_headers
+} from "./permission-1xksxgzs.js";
+import {
+  exports_model_http
+} from "./permission-93qdgxxd.js";
+import {
+  exports_token
+} from "./permission-v972xay6.js";
+import {
+  llmClient
+} from "./permission-m01ryvbe.js";
+import {
+  toSessionError
+} from "./permission-42xz94rv.js";
+import {
+  exports_model
+} from "./permission-14dbm5wf.js";
+import {
+  exports_hooks
+} from "./permission-t2j2ttmx.js";
+import {
+  exports_app
+} from "./permission-50jxp3hw.js";
+import {
+  exports_config
+} from "./permission-k59zb4v2.js";
+import {
+  SessionEvent
+} from "./permission-a83yvq99.js";
+import {
+  exports_agent
+} from "./permission-0c101nc9.js";
+import {
+  exports_bus
+} from "./permission-r5ce0emk.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/session/compaction.ts
+var exports_compaction = {};
+__export(exports_compaction, {
+  serializeToolContent: () => serializeToolContent,
+  node: () => node,
+  layer: () => layer,
+  buildPrompt: () => buildPrompt,
+  SessionCompaction: () => exports_compaction,
+  Service: () => Service
+});
+import { LLM, LLMClient, LLMEvent, Message } from "@opencode-ai/ai";
+import { Context, Effect, Layer, Stream } from "effect";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+var DEFAULT_BUFFER = 20000;
+var DEFAULT_KEEP_TOKENS = 15000;
+var OUTPUT_TOKEN_MAX = 32000;
+var TOOL_OUTPUT_MAX_CHARS = 2000;
+var SUMMARY_TEMPLATE = `Output exactly the Markdown structure shown inside <template> and keep the section order unchanged. Do not include the <template> tags in your response.
+<template>
+## Objective
+- [one or two brief sentences describing what the user is trying to accomplish]
+
+## Important Details
+- [constraints/preferences, decisions and why, important facts/assumptions, exact context needed to continue, or "(none)"]
+
+## Work State
+### Completed
+- [finished work, verified facts, or changes made; otherwise "(none)"]
+
+### Active
+- [current work, partial changes, or investigation state; otherwise "(none)"]
+
+### Blocked
+- [blockers, failing commands, or unknowns; otherwise "(none)"]
+
+## Next Move
+1. [immediate concrete action, or "(none)"]
+2. [next action if known, or "(none)"]
+
+## Relevant Files
+- [file or directory path: why it matters, or "(none)"]
+</template>
+
+Rules:
+- Keep every section, even when empty.
+- Use terse bullets, not prose paragraphs.
+- Preserve exact file paths, symbols, commands, error strings, URLs, and identifiers when known.
+- Do not mention the summary process or that context was compacted.`;
+
+class Service extends Context.Service()("@opencode/SessionCompaction") {
+}
+var truncate = (value) => value.length <= TOOL_OUTPUT_MAX_CHARS ? value : `${value.slice(0, TOOL_OUTPUT_MAX_CHARS)}
+[truncated]`;
+var serializeToolContent = (content) => content.map((item) => item.type === "text" ? item.text : `[Attached ${item.mime}${item.name === undefined ? "" : `: ${item.name}`}]`).join(`
+`);
+var serialize = (message) => {
+  if (message.type === "user") {
+    const files = message.files?.map((file) => `[Attached ${file.mime}: ${file.name ?? (file.source.type === "uri" ? file.source.uri : "inline attachment")}]`) ?? [];
+    const skills = message.skills?.map((skill) => `[Attached skill: ${skill.name}]
+${skill.text}`) ?? [];
+    return [`[User]: ${message.text}`, ...skills, ...files].join(`
+`);
+  }
+  if (message.type === "location-switched")
+    return `[User]: The working directory has been changed to ${message.location.directory}.`;
+  if (message.type === "assistant") {
+    return message.content.flatMap((part) => {
+      if (part.type === "text")
+        return [`[Assistant]: ${part.text}`];
+      if (part.type === "reasoning")
+        return part.text ? [`[Assistant reasoning]: ${part.text}`] : [];
+      const input = typeof part.state.input === "string" ? part.state.input : JSON.stringify(part.state.input);
+      if (part.state.status === "completed")
+        return [
+          `[Assistant tool call]: ${part.name}(${input})`,
+          `[Tool result]: ${truncate(serializeToolContent(part.state.content))}`
+        ];
+      if (part.state.status === "error")
+        return [`[Assistant tool call]: ${part.name}(${input})`, `[Tool error]: ${part.state.error.message}`];
+      return [`[Assistant tool call]: ${part.name}(${input})`];
+    }).join(`
+`);
+  }
+  if (message.type === "system")
+    return `[System update]: ${message.text}`;
+  if (message.type === "synthetic")
+    return `[Synthetic context]: ${message.text}`;
+  if (message.type === "skill")
+    return `[Skill activated: ${message.name}]
+${message.text}`;
+  if (message.type === "shell")
+    return `[Shell]: ${message.command}
+${truncate(message.output?.output ?? "")}`;
+  return "";
+};
+var settings = (documents) => {
+  const configured = documents.filter((entry) => entry.type === "document").flatMap((entry) => entry.info.compaction ? [entry.info.compaction] : []);
+  return {
+    auto: configured.findLast((value) => value.auto !== undefined)?.auto ?? true,
+    buffer: configured.findLast((value) => value.buffer !== undefined)?.buffer ?? DEFAULT_BUFFER,
+    tokens: configured.findLast((value) => value.keep?.tokens !== undefined)?.keep?.tokens ?? DEFAULT_KEEP_TOKENS
+  };
+};
+var select = (messages, tokens) => {
+  const conversation = messages.filter((message) => message.type !== "compaction" && message.type !== "system").flatMap((message) => {
+    const text = serialize(message);
+    return text ? [{ message, text }] : [];
+  });
+  if (conversation.length === 0)
+    return;
+  let total = 0;
+  let split = conversation.length;
+  for (let index = conversation.length - 1;index >= 0; index--) {
+    const next = total + exports_token.estimate(conversation[index].text);
+    if (split < conversation.length && next > tokens)
+      break;
+    total = next;
+    split = index;
+  }
+  while (split > 0 && conversation[split].message.type !== "user")
+    split--;
+  if (split === 0) {
+    const latestUser = conversation.findLastIndex((item) => item.message.type === "user");
+    if (latestUser > 0)
+      split = latestUser;
+  }
+  return {
+    head: conversation.slice(0, split).map((item) => item.text).join(`
+
+`),
+    recent: conversation.slice(split).map((item) => item.text).join(`
+
+`)
+  };
+};
+var buildPrompt = (input) => [
+  input.previousSummary ? `Update the anchored summary below using the conversation history above.
+Preserve still-true details, remove stale details, and merge in the new facts.
+<previous-summary>
+${input.previousSummary}
+</previous-summary>` : "Create a new anchored summary from the conversation history.",
+  SUMMARY_TEMPLATE,
+  "The following is the conversation history:",
+  ...input.context
+].join(`
+
+`);
+var planContent = (messages, tokens) => {
+  const selected = select(messages, tokens);
+  if (!selected)
+    return;
+  const previousSummary = messages.findLast((message) => message.type === "compaction" && message.status === "completed");
+  const previousRecent = previousSummary?.type === "compaction" ? previousSummary.recent : "";
+  const summarizeRecent = !previousRecent && !selected.head;
+  return {
+    prompt: buildPrompt({
+      previousSummary: previousSummary?.type === "compaction" ? previousSummary.summary : undefined,
+      context: summarizeRecent ? [selected.recent] : [previousRecent, selected.head].filter(Boolean)
+    }),
+    recent: summarizeRecent ? "" : selected.recent
+  };
+};
+var make = (dependencies) => {
+  const config = dependencies.config;
+  const failed = Effect.fnUntraced(function* (input) {
+    yield* dependencies.bus.publish(SessionEvent.Compaction.Failed, input);
+    return { status: "failed", error: input.error };
+  });
+  const execute = Effect.fn("SessionCompaction.execute")(function* (plan) {
+    yield* dependencies.bus.publish(SessionEvent.Compaction.Started, {
+      sessionID: plan.session.id,
+      reason: plan.reason,
+      recent: plan.recent,
+      inputID: plan.inputID
+    });
+    const chunks = [];
+    let failure;
+    let usage;
+    const recordUsage = Effect.suspend(() => usage ? dependencies.bus.publish(SessionEvent.UsageRecorded, {
+      sessionID: plan.session.id,
+      source: "compaction",
+      ...usage
+    }) : Effect.void);
+    yield* dependencies.llm.stream(LLM.request({
+      model: plan.model,
+      promptCacheKey: exports_prompt_cache_key.make(plan.session.id),
+      http: { headers: exports_model_headers.make(plan.session, dependencies.app) },
+      messages: [Message.user(plan.prompt)],
+      tools: []
+    }), {
+      http: exports_model_http.middleware(dependencies.hooks, {
+        sessionID: plan.session.id,
+        agent: exports_agent.ID.make("compaction"),
+        model: plan.ref
+      })
+    }).pipe(Stream.runForEach((event) => {
+      if (LLMEvent.is.providerError(event))
+        failure = {
+          type: event.classification === "context-overflow" ? "provider.invalid-request" : "provider.error",
+          message: event.message
+        };
+      if (LLMEvent.is.textDelta(event)) {
+        chunks.push(event.text);
+        return dependencies.bus.publish(SessionEvent.Compaction.Delta, {
+          sessionID: plan.session.id,
+          text: event.text
+        });
+      }
+      if (LLMEvent.is.stepFinish(event)) {
+        const step = exports_usage.record(event.usage, plan.cost);
+        usage = usage ? exports_usage.add(usage, step) : step;
+      }
+      return Effect.void;
+    }), Effect.catchTag("AI.Error", (error) => Effect.sync(() => {
+      failure = toSessionError(error);
+    })), Effect.onInterrupt(() => recordUsage.pipe(Effect.andThen(plan.reason === "auto" ? failed({
+      sessionID: plan.session.id,
+      reason: plan.reason,
+      error: { type: "compaction.interrupted", message: "Compaction was interrupted" },
+      inputID: plan.inputID
+    }).pipe(Effect.asVoid) : Effect.void))));
+    yield* recordUsage;
+    const summary = chunks.join("");
+    if (failure || !summary.trim()) {
+      const error = failure ?? { type: "compaction.failed", message: "Compaction produced no summary" };
+      return yield* failed({
+        sessionID: plan.session.id,
+        reason: plan.reason,
+        error,
+        inputID: plan.inputID
+      });
+    }
+    yield* dependencies.bus.publish(SessionEvent.Compaction.Ended, {
+      sessionID: plan.session.id,
+      reason: plan.reason,
+      text: summary,
+      recent: plan.recent
+    });
+    return { status: "completed" };
+  });
+  const compact = Effect.fn("SessionCompaction.compact")(function* (input) {
+    const content = planContent(input.messages, config.tokens);
+    if (content)
+      return yield* execute({
+        session: input.session,
+        model: input.model,
+        ref: input.ref,
+        cost: input.cost,
+        reason: "auto",
+        ...content
+      });
+    const error = { type: "compaction.unavailable", message: "Nothing to compact yet" };
+    return yield* failed({
+      sessionID: input.session.id,
+      reason: "auto",
+      error
+    });
+  });
+  const required = (input) => {
+    if (!config.auto)
+      return false;
+    const context = input.model.route.defaults.limits?.context;
+    if (context === undefined || context <= 0)
+      return false;
+    const last = input.messages.findLast((message) => message.type === "assistant" && message.tokens !== undefined);
+    if (!last)
+      return false;
+    const limits = input.model.route.defaults.limits;
+    const output = Math.min(limits?.output ?? 0, OUTPUT_TOKEN_MAX);
+    const promptCeiling = Math.min(limits?.input === undefined ? Number.POSITIVE_INFINITY : limits.input - config.buffer, context - Math.max(output, config.buffer));
+    const used = last.tokens.input + last.tokens.output + last.tokens.reasoning + last.tokens.cache.read + last.tokens.cache.write;
+    if (used <= 0)
+      return false;
+    return used >= promptCeiling;
+  };
+  const compactManual = Effect.fn("SessionCompaction.compactManual")(function* (input) {
+    const content = planContent(input.messages, config.tokens);
+    if (!content)
+      return yield* failed({
+        sessionID: input.session.id,
+        reason: "manual",
+        error: { type: "compaction.unavailable", message: "Nothing to compact yet" },
+        inputID: input.inputID
+      });
+    const resolved = yield* dependencies.models.resolve(input.session).pipe(Effect.catch((cause) => failed({
+      sessionID: input.session.id,
+      reason: "manual",
+      error: toSessionError(cause),
+      inputID: input.inputID
+    })));
+    if ("status" in resolved)
+      return resolved;
+    return yield* execute({
+      session: input.session,
+      model: resolved.model,
+      ref: resolved.ref,
+      cost: resolved.cost,
+      reason: "manual",
+      inputID: input.inputID,
+      ...content
+    });
+  });
+  return Service.of({
+    required,
+    compact,
+    compactManual
+  });
+};
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const bus = yield* exports_bus.Service;
+  const llm = yield* LLMClient.Service;
+  const config = yield* exports_config.Service;
+  const models = yield* exports_model.Service;
+  const app = yield* exports_app.Metadata;
+  const hooks = yield* exports_hooks.Service;
+  return make({ bus, llm, models, config: settings(yield* config.entries()), app, hooks });
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [exports_bus.node, llmClient, exports_config.node, exports_model.node, exports_app.node, exports_hooks.node]
+});
+
+export { Service, serializeToolContent, buildPrompt, layer, node, exports_compaction };

package/dist/chunks/permission-zthe9zqc.js

@@ -0,0 +1,36 @@
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/environment/files.ts
+var exports_files = {};
+__export(exports_files, {
+  typeFollowing: () => typeFollowing,
+  WrongKind: () => WrongKind,
+  NotFound: () => NotFound,
+  FileType: () => FileType,
+  Failed: () => Failed,
+  EnvironmentFiles: () => exports_files
+});
+import { Effect, Schema } from "effect";
+var FileType = Schema.Literals(["file", "directory", "symlink", "other"]);
+
+class NotFound extends Schema.TaggedErrorClass()("Environment.NotFound", {
+  path: Schema.String
+}) {
+}
+
+class WrongKind extends Schema.TaggedErrorClass()("Environment.WrongKind", {
+  path: Schema.String,
+  actual: FileType
+}) {
+}
+
+class Failed extends Schema.TaggedErrorClass()("Environment.Failed", {
+  path: Schema.String,
+  cause: Schema.Defect()
+}) {
+}
+var typeFollowing = (files, path) => files.stat(path).pipe(Effect.flatMap((info) => info.type === "symlink" ? files.read(path, { offset: 0, length: 0 }).pipe(Effect.map((result) => result.info.type), Effect.catchTag("Environment.WrongKind", (error) => Effect.succeed(error.actual))) : Effect.succeed(info.type)));
+
+export { FileType, NotFound, WrongKind, Failed, typeFollowing, exports_files };