@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-g8mks886.js

@@ -0,0 +1,366 @@
+import {
+  webSocketConstructor2
+} from "./repository-5t3nmthw.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/session/model-transport.ts
+var exports_model_transport = {};
+__export(exports_model_transport, {
+  Service: () => Service37,
+  SessionModelTransport: () => exports_model_transport,
+  layer: () => layer15,
+  makeLayer: () => makeLayer2,
+  node: () => node41
+});
+import {
+  WebSocketTransport
+} from "@opencode/ai/route";
+import { AIError, AIErrorReason, TransportError } from "@opencode/ai";
+import { Hash } from "@opencode/util/hash";
+import { Cause, Clock, Context, Effect, Fiber, Layer, Metric, Queue, Scope, Semaphore, Stream } from "effect";
+import { Socket } from "effect/unstable/socket";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+var ROTATE_AFTER_MS = 55 * 60 * 1000;
+var INBOUND_CAPACITY = 128;
+var CONNECT_TIMEOUT = "10 seconds";
+var IDLE_TIMEOUT = "5 minutes";
+var events = Metric.counter("opencode_session_websocket_events_total", {
+  description: "Session WebSocket lifecycle events",
+  incremental: true
+});
+var metric = (event, attributes = {}) => Metric.update(events.pipe(Metric.withAttributes({ event, ...attributes })), 1);
+
+class Service37 extends Context.Service()("@opencode/SessionModelTransport") {
+}
+var transportError = (message, input) => new AIError({
+  reason: new TransportError({ message, transport: "websocket", ...input })
+});
+var annotate = (error, input) => {
+  if (error.reason._tag !== "Transport")
+    return error;
+  return new AIError({
+    reason: new TransportError({
+      ...error.reason,
+      message: error.message,
+      cause: error.reason.cause,
+      ...input
+    })
+  });
+};
+var affinity = (exchange) => `${exchange.connect.url}:${Hash.sha256(JSON.stringify(Object.entries(exchange.connect.headers).sort(([a], [b]) => a.localeCompare(b))))}`;
+var observationFrame = (observation) => {
+  if (observation.type === "frame" || observation.type === "completed" || observation.type === "incomplete")
+    return Effect.succeed(observation.frame);
+  return Effect.fail(observation.error);
+};
+var observationTerminal = (observation) => observation.type !== "frame";
+var makeLayer2 = (connector) => Layer.effect(Service37, Effect.gen(function* () {
+  const scope = yield* Scope.Scope;
+  const states = new Map;
+  const state = (sessionID) => {
+    const current = states.get(sessionID);
+    if (current)
+      return current;
+    const created = { lock: Semaphore.makeUnsafe(1), closed: false, httpFallback: false };
+    states.set(sessionID, created);
+    return created;
+  };
+  const closeChannel = Effect.fn("SessionModelTransport.closeChannel")(function* (owner, channel) {
+    if (owner.channel === channel)
+      owner.channel = undefined;
+    if (channel.closing)
+      return;
+    channel.closing = true;
+    if (channel.reader)
+      yield* Fiber.interrupt(channel.reader);
+    yield* channel.connection.close;
+    if (channel.active)
+      Queue.failCauseUnsafe(channel.active.queue, Cause.fail(transportError("Session WebSocket closed", {
+        operation: "read",
+        code: "close",
+        phase: "close",
+        delivery: channel.active.delivery === "provider-observed" || channel.active.delivery === "terminal" ? "accepted" : "ambiguous"
+      })));
+    yield* metric("close");
+  });
+  const poison = Effect.fn("SessionModelTransport.poison")(function* (owner, channel, error) {
+    if (owner.channel === channel)
+      owner.channel = undefined;
+    if (channel.closing)
+      return;
+    channel.closing = true;
+    yield* Effect.logDebug("session websocket poisoned", {
+      sessionTransport: "websocket",
+      code: error.reason._tag === "Transport" ? error.reason.code : error.reason._tag,
+      active: channel.active !== undefined
+    });
+    if (channel.active)
+      Queue.failCauseUnsafe(channel.active.queue, Cause.fail(error));
+    yield* metric(error.reason._tag === "Transport" && error.reason.code === "queue-overflow" ? "queue_overflow" : "protocol_failure");
+    yield* channel.connection.close;
+  });
+  const open = Effect.fn("SessionModelTransport.open")(function* (owner, exchange, key) {
+    return yield* Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+      const connection = yield* restore(connector.open(exchange.connect).pipe(Effect.timeoutOrElse({
+        duration: CONNECT_TIMEOUT,
+        orElse: () => transportError("Timed out opening the Session WebSocket", {
+          url: exchange.connect.url,
+          operation: "request",
+          code: "connect-timeout",
+          phase: "connect",
+          delivery: "not-sent"
+        })
+      }), Effect.withSpan("SessionModelTransport.connect")));
+      if (owner.closed) {
+        yield* connection.close;
+        return yield* transportError("Session WebSocket owner closed while connecting", {
+          operation: "request",
+          code: "owner-closed",
+          phase: "connect",
+          delivery: "not-sent"
+        });
+      }
+      const channel = {
+        affinity: key,
+        connection,
+        openedAt: yield* Clock.currentTimeMillis,
+        closing: false
+      };
+      owner.channel = channel;
+      channel.reader = yield* connection.messages.pipe(Stream.runForEach((message) => Effect.gen(function* () {
+        const active = channel.active;
+        if (!active)
+          return yield* transportError("WebSocket data arrived without an active exchange", {
+            url: exchange.connect.url,
+            operation: "read",
+            code: "idle-data",
+            phase: "receive"
+          });
+        active.delivery = "provider-observed";
+        if (typeof message !== "string")
+          return yield* transportError("Unsupported binary WebSocket frame", {
+            url: exchange.connect.url,
+            operation: "read",
+            code: "message",
+            phase: "receive"
+          });
+        if (Queue.offerUnsafe(active.queue, message))
+          return;
+        return yield* transportError("Session WebSocket inbound queue overflow", {
+          url: exchange.connect.url,
+          operation: "read",
+          code: "queue-overflow",
+          phase: "receive",
+          delivery: "accepted"
+        });
+      })), Effect.catch((error) => channel.closing ? Effect.void : poison(owner, channel, annotate(error, {
+        phase: error.reason._tag === "Transport" && error.reason.phase === "close" ? "close" : "receive",
+        delivery: channel.active?.delivery === "provider-observed" || channel.active?.delivery === "terminal" || error.reason._tag === "Transport" && error.reason.code === "queue-overflow" ? "accepted" : error.reason._tag === "Transport" && error.reason.code === "1009" ? "rejected" : "ambiguous"
+      }))), Effect.forkIn(scope, { startImmediately: true }));
+      yield* Effect.logDebug("session websocket connected", {
+        sessionTransport: "websocket",
+        phase: "connect"
+      });
+      yield* metric("connect");
+      return channel;
+    }));
+  });
+  const fallback = (exchange) => ({
+    frames: exchange.fallback(),
+    complete: Effect.void
+  });
+  const start = Effect.fn("SessionModelTransport.start")(function* (owner, exchange) {
+    if (owner.closed)
+      return yield* transportError("Session WebSocket owner is closed", {
+        operation: "request",
+        code: "owner-closed",
+        phase: "queue",
+        delivery: "not-sent"
+      });
+    if (owner.httpFallback)
+      return fallback(exchange);
+    const key = affinity(exchange);
+    const now = yield* Clock.currentTimeMillis;
+    const current = owner.channel;
+    const rotateAfterMs = exchange.connect.rotateAfterMs ?? ROTATE_AFTER_MS;
+    const rotation = current ? current.affinity !== key ? "affinity" : now - current.openedAt >= rotateAfterMs ? "age" : undefined : undefined;
+    if (current && rotation) {
+      yield* Effect.logDebug("session websocket rotating", {
+        sessionTransport: "websocket",
+        phase: "connect",
+        reason: rotation
+      });
+      yield* metric("rotation", { reason: rotation });
+      yield* metric("reconnect");
+      yield* closeChannel(owner, current);
+    }
+    if (owner.channel)
+      yield* Effect.logDebug("session websocket reused", {
+        sessionTransport: "websocket",
+        phase: "connect"
+      });
+    if (owner.channel)
+      yield* metric("reuse");
+    const channel = owner.channel ? owner.channel : yield* open(owner, exchange, key).pipe(Effect.catch((error) => {
+      if (error.reason._tag === "Transport" && error.reason.code === "owner-closed")
+        return Effect.fail(error);
+      owner.httpFallback = true;
+      return Effect.logWarning("session websocket connect failed; using http", {
+        sessionTransport: "websocket",
+        phase: "connect",
+        delivery: "not-sent",
+        code: error.reason._tag === "Transport" ? error.reason.code : error.reason._tag
+      }).pipe(Effect.andThen(metric("connect_failure")), Effect.andThen(metric("fallback")), Effect.as(undefined));
+    }));
+    if (!channel)
+      return fallback(exchange);
+    if (channel.pending) {
+      channel.pending = undefined;
+      channel.checkpoint = undefined;
+    }
+    const create = yield* exchange.driver.create(channel.checkpoint).pipe(Effect.tapError(() => closeChannel(owner, channel)), Effect.onInterrupt(() => closeChannel(owner, channel)));
+    if (create.mode === "full")
+      channel.checkpoint = undefined;
+    yield* Effect.logDebug("session websocket sending", {
+      sessionTransport: "websocket",
+      phase: "send",
+      mode: create.mode
+    });
+    const active = {
+      queue: yield* Queue.bounded(INBOUND_CAPACITY),
+      delivery: "send-attempted"
+    };
+    channel.active = active;
+    const sent = yield* channel.connection.sendText(create.message).pipe(Effect.withSpan("SessionModelTransport.send"), Effect.onInterrupt(() => closeChannel(owner, channel)), Effect.result);
+    if (sent._tag === "Failure") {
+      const failure = new AIError({
+        reason: AIErrorReason.make({
+          ...sent.failure.reason,
+          message: sent.failure.message,
+          cause: sent.failure.reason.cause,
+          http: sent.failure.reason.http ?? channel.connection.http
+        })
+      });
+      const notSent = failure.reason._tag === "Transport" && failure.reason.delivery === "not-sent";
+      yield* closeChannel(owner, channel);
+      if (notSent) {
+        yield* metric("fallback");
+        return fallback(exchange);
+      }
+      yield* metric("ambiguous_delivery");
+      return yield* annotate(failure, { phase: "send", delivery: "ambiguous" });
+    }
+    yield* metric("send");
+    let terminal;
+    const token = {};
+    const frames = Stream.fromQueue(active.queue).pipe(Stream.timeoutOrElse({
+      duration: IDLE_TIMEOUT,
+      orElse: () => Stream.fail(transportError("Timed out waiting for WebSocket data", {
+        url: exchange.connect.url,
+        operation: "read",
+        code: "idle-timeout",
+        phase: "receive",
+        delivery: active.delivery === "provider-observed" ? "accepted" : "ambiguous"
+      }))
+    }), Stream.mapEffect((frame) => exchange.driver.observe(create, frame)), Stream.tap((observation) => Effect.sync(() => {
+      if (!observationTerminal(observation))
+        return;
+      terminal = observation;
+      active.delivery = "terminal";
+      const staged = observation.type === "completed" ? observation.checkpoint : undefined;
+      if (staged)
+        channel.pending = { token, checkpoint: staged };
+      if (observation.type !== "completed" || !staged)
+        channel.checkpoint = undefined;
+    })), Stream.takeUntil(observationTerminal), Stream.mapEffect(observationFrame), Stream.ensuring(Effect.gen(function* () {
+      if (channel.active === active)
+        channel.active = undefined;
+      const pending = yield* Queue.size(active.queue);
+      yield* Queue.shutdown(active.queue);
+      if (terminal && pending === 0) {
+        yield* metric("terminal", { type: terminal.type });
+        if (terminal.type === "rejected")
+          yield* metric("rejection", { recovery: terminal.recovery });
+        if (terminal.type !== "completed" && terminal.type !== "incomplete")
+          yield* closeChannel(owner, channel);
+        return;
+      }
+      yield* metric("cancellation");
+      channel.checkpoint = undefined;
+      channel.pending = undefined;
+      const error = terminal ? transportError("WebSocket data arrived after the terminal event", {
+        url: exchange.connect.url,
+        operation: "read",
+        code: "idle-data",
+        phase: "receive",
+        delivery: "accepted"
+      }) : transportError("Session WebSocket exchange did not reach a terminal event", {
+        url: exchange.connect.url,
+        operation: "read",
+        code: "incomplete",
+        phase: "receive",
+        delivery: active.delivery === "provider-observed" ? "accepted" : "ambiguous"
+      });
+      yield* poison(owner, channel, error);
+    })), Stream.catch((error) => {
+      if (error.reason._tag !== "Transport" || error.reason.code !== "1009" || error.reason.delivery !== "rejected")
+        return Stream.fail(error);
+      owner.httpFallback = true;
+      return Stream.unwrap(Effect.logWarning("session websocket request too large; using http", {
+        sessionTransport: "websocket",
+        phase: "close",
+        delivery: "rejected",
+        code: error.reason.code
+      }).pipe(Effect.andThen(metric("fallback", { reason: "message_too_large" })), Effect.as(exchange.fallback())));
+    }));
+    const complete = Effect.sync(() => {
+      if (owner.channel !== channel || channel.pending?.token !== token)
+        return;
+      channel.checkpoint = channel.pending.checkpoint;
+      channel.pending = undefined;
+    });
+    return { frames, complete, http: channel.connection.http };
+  });
+  const bind = (sessionID) => ({
+    execute: (exchange) => {
+      const owner = state(sessionID);
+      let execution;
+      return Effect.succeed({
+        get http() {
+          return execution?.http;
+        },
+        frames: Stream.unwrap(Effect.acquireRelease(owner.lock.take(1), () => owner.lock.release(1), { interruptible: true }).pipe(Effect.andThen(start(owner, exchange)), Effect.tap((started) => Effect.sync(() => {
+          execution = started;
+        })), Effect.map((started) => started.frames))),
+        complete: Effect.suspend(() => execution?.complete ?? Effect.void)
+      });
+    }
+  });
+  const close = Effect.fn("SessionModelTransport.close")(function* (sessionID) {
+    const owner = states.get(sessionID);
+    if (!owner)
+      return;
+    states.delete(sessionID);
+    owner.closed = true;
+    if (owner.channel)
+      yield* closeChannel(owner, owner.channel);
+  });
+  const closeAll = Effect.suspend(() => {
+    const owners = Array.from(states.values());
+    states.clear();
+    return Effect.forEach(owners, (owner) => {
+      owner.closed = true;
+      return owner.channel ? closeChannel(owner, owner.channel) : Effect.void;
+    }, { discard: true });
+  });
+  yield* Effect.addFinalizer(() => closeAll);
+  return Service37.of({ bind, close, closeAll });
+}));
+var layer15 = Layer.unwrap(Effect.map(Socket.WebSocketConstructor, (constructor) => makeLayer2({
+  open: (input) => WebSocketTransport.open(input).pipe(Effect.provideService(Socket.WebSocketConstructor, constructor))
+})));
+var node41 = makeGlobalNode({ service: Service37, layer: layer15, deps: [webSocketConstructor2] });
+
+export { Service37, makeLayer2, layer15, node41, exports_model_transport };

package/dist/chunks/repository-g9cr3d5v.js

@@ -0,0 +1,341 @@
+import {
+  ps2
+} from "./repository-3ke3s58r.js";
+import {
+  lazy2
+} from "./repository-88xbtdfr.js";
+import {
+  match2
+} from "./repository-y1fvbwt7.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/shell/parse.ts
+var exports_parse = {};
+__export(exports_parse, {
+  ShellParse: () => exports_parse,
+  scan: () => scan2,
+  scanPortable: () => scanPortable2
+});
+import { Effect } from "effect";
+import { fileURLToPath } from "url";
+import os from "os";
+import path from "path";
+import { shellParserWasm } from "#shell-parser-wasm";
+var CWD = new Set(["cd", "chdir", "popd", "pushd", "push-location", "set-location"]);
+var POWERSHELL_PATH_FLAGS = new Set(["-literalpath", "-path"]);
+var ARITY = {
+  cat: 1,
+  cd: 1,
+  chmod: 1,
+  chown: 1,
+  cp: 1,
+  echo: 1,
+  env: 1,
+  export: 1,
+  grep: 1,
+  kill: 1,
+  killall: 1,
+  ln: 1,
+  ls: 1,
+  mkdir: 1,
+  mv: 1,
+  ps: 1,
+  pwd: 1,
+  rm: 1,
+  rmdir: 1,
+  sleep: 1,
+  source: 1,
+  tail: 1,
+  touch: 1,
+  unset: 1,
+  which: 1,
+  aws: 3,
+  az: 3,
+  bazel: 2,
+  brew: 2,
+  bun: 2,
+  "bun run": 3,
+  "bun x": 3,
+  cargo: 2,
+  "cargo add": 3,
+  "cargo run": 3,
+  cdk: 2,
+  cf: 2,
+  cmake: 2,
+  composer: 2,
+  consul: 2,
+  "consul kv": 3,
+  crictl: 2,
+  deno: 2,
+  "deno task": 3,
+  doctl: 3,
+  docker: 2,
+  "docker builder": 3,
+  "docker compose": 3,
+  "docker container": 3,
+  "docker image": 3,
+  "docker network": 3,
+  "docker volume": 3,
+  eksctl: 2,
+  "eksctl create": 3,
+  firebase: 2,
+  flyctl: 2,
+  gcloud: 3,
+  gh: 3,
+  git: 2,
+  "git config": 3,
+  "git remote": 3,
+  "git stash": 3,
+  go: 2,
+  gradle: 2,
+  helm: 2,
+  heroku: 2,
+  hugo: 2,
+  ip: 2,
+  "ip addr": 3,
+  "ip link": 3,
+  "ip netns": 3,
+  "ip route": 3,
+  kind: 2,
+  "kind create": 3,
+  kubectl: 2,
+  "kubectl kustomize": 3,
+  "kubectl rollout": 3,
+  kustomize: 2,
+  make: 2,
+  mc: 2,
+  "mc admin": 3,
+  minikube: 2,
+  mongosh: 2,
+  mysql: 2,
+  mvn: 2,
+  ng: 2,
+  npm: 2,
+  "npm exec": 3,
+  "npm init": 3,
+  "npm run": 3,
+  "npm view": 3,
+  npx: 2,
+  nvm: 2,
+  nx: 2,
+  openssl: 2,
+  "openssl req": 3,
+  "openssl x509": 3,
+  pip: 2,
+  pipenv: 2,
+  pnpm: 2,
+  "pnpm dlx": 3,
+  "pnpm exec": 3,
+  "pnpm run": 3,
+  poetry: 2,
+  podman: 2,
+  "podman container": 3,
+  "podman image": 3,
+  psql: 2,
+  pulumi: 2,
+  "pulumi stack": 3,
+  python: 2,
+  pyenv: 2,
+  rake: 2,
+  rbenv: 2,
+  "redis-cli": 2,
+  rustup: 2,
+  serverless: 2,
+  sfdx: 3,
+  skaffold: 2,
+  sls: 2,
+  sst: 2,
+  swift: 2,
+  systemctl: 2,
+  terraform: 2,
+  "terraform workspace": 3,
+  tmux: 2,
+  turbo: 2,
+  ufw: 2,
+  vault: 2,
+  "vault auth": 3,
+  "vault kv": 3,
+  vercel: 2,
+  volta: 2,
+  wp: 2,
+  yarn: 2,
+  "yarn dlx": 3,
+  "yarn run": 3
+};
+var PREFIX_LENGTH = Math.max(...Object.values(ARITY));
+var scan2 = Effect.fnUntraced(function* (command, shell, cwd, options) {
+  if (options?.portable)
+    return yield* scanPortable2(command, shell, cwd);
+  return yield* scanLegacy(command, shell, cwd);
+});
+var scanLegacy = Effect.fnUntraced(function* (command, shell, cwd) {
+  const parsers = yield* Effect.promise(load);
+  const powershell = ps2(shell);
+  const tree = (powershell ? parsers.ps : parsers.bash).parse(command);
+  if (!tree)
+    return yield* Effect.fail(new Error("Failed to parse shell command"));
+  return yield* Effect.acquireUseRelease(Effect.succeed(tree), (tree) => Effect.sync(() => tree.rootNode.descendantsOfType("command").reduce((result, node) => {
+    if (!node)
+      return result;
+    const command = parts(node);
+    const tokens = command.map((part) => part.text);
+    if (tokens.length === 0)
+      return result;
+    const name = powershell ? tokens[0].toLowerCase() : tokens[0];
+    if (CWD.has(name)) {
+      result.directories.push(...directoryArgs(command, powershell, cwd, shell));
+      return result;
+    }
+    result.commands.push({
+      resource: (node.parent?.type === "redirected_statement" ? node.parent.text : node.text).trim(),
+      save: `${prefix(tokens).join(" ")} *`
+    });
+    return result;
+  }, { commands: [], directories: [] })), (tree) => Effect.sync(() => tree.delete()));
+});
+var scanPortable2 = Effect.fnUntraced(function* (command, shell, cwd) {
+  const { ShellScan } = yield* Effect.tryPromise({
+    try: () => import("../shell/scan.js"),
+    catch: (cause) => new Error(`Portable shell scanner failed to load: ${cause}`, { cause })
+  });
+  const powershell = ps2(shell);
+  const result = powershell ? ShellScan.scanPowerShell(command) : ShellScan.scan(command);
+  if (result.kind === "opaque")
+    return yield* Effect.fail(new Error(`Portable shell scanner cannot analyze command: ${result.reason}`));
+  const output = { commands: [], directories: [] };
+  for (const item of result.commands) {
+    if (item.declaration)
+      continue;
+    const words = item.redirectWordCount === undefined ? item.rawWords : item.rawWords.slice(0, item.redirectWordCount);
+    if (powershell && item.statementHead && /^foreach(?:-|$)/i.test(words[0] ?? ""))
+      continue;
+    const name = powershell ? words[0]?.toLowerCase() : words[0];
+    if (CWD.has(name)) {
+      output.directories.push(...directoryArgs(words.flatMap((text) => {
+        const parameter = powershell ? /^(-(?:literalpath|path)):(.*)$/i.exec(text) : undefined;
+        if (parameter)
+          return [
+            { type: "command_parameter", text: parameter[1] },
+            { type: "word", text: parameter[2] }
+          ];
+        return [{ type: powershell && text.startsWith("-") ? "command_parameter" : "word", text }];
+      }), powershell, cwd, shell));
+      continue;
+    }
+    const selected = prefix(words.slice(0, PREFIX_LENGTH));
+    const conventional = `${selected.join(" ")} *`;
+    const end = item.wordEnds?.[selected.length - 1];
+    const save = !powershell || end === undefined || match2(item.resource, conventional) ? conventional : (() => {
+      const boundary = item.wordEnds?.find((value) => value >= end && (value >= item.resource.length || /\s/.test(item.resource[value]))) ?? end;
+      const separator = /^\s+(?:`(?:\r\n|\r|\n)\s*)?/.exec(item.resource.slice(boundary))?.[0];
+      return `${item.resource.slice(0, boundary)}${separator ?? " "}*`;
+    })();
+    output.commands.push({
+      resource: item.resource,
+      save
+    });
+  }
+  return output;
+});
+function parts(node) {
+  return Array.from({ length: node.childCount }).flatMap((_, index) => {
+    const child = node.child(index);
+    if (!child)
+      return [];
+    if (child.type === "command_elements")
+      return Array.from({ length: child.childCount }).flatMap((_, itemIndex) => {
+        const item = child.child(itemIndex);
+        if (!item || item.type === "command_argument_sep" || item.type === "redirection")
+          return [];
+        return [{ type: item.type, text: item.text }];
+      });
+    if (!["command_name", "command_name_expr", "word", "string", "raw_string", "concatenation"].includes(child.type))
+      return [];
+    return [{ type: child.type, text: child.text }];
+  });
+}
+function directoryArgs(command, powershell, cwd, shell) {
+  if (!powershell)
+    return command.slice(1).filter((part) => !part.text.startsWith("-")).map((part) => directoryArgument(part.text, powershell, cwd, shell)).filter((part) => part !== undefined);
+  const directories = [];
+  let path2 = false;
+  for (const part of command.slice(1)) {
+    if (path2) {
+      const value = directoryArgument(part.text, powershell, cwd, shell);
+      if (value)
+        directories.push(value);
+      path2 = false;
+      continue;
+    }
+    if (part.type === "command_parameter") {
+      path2 = POWERSHELL_PATH_FLAGS.has(part.text.toLowerCase());
+      continue;
+    }
+    const value = directoryArgument(part.text, powershell, cwd, shell);
+    if (value)
+      directories.push(value);
+  }
+  return directories;
+}
+function directoryArgument(value, powershell, cwd, shell) {
+  const quote = value[0];
+  const text = (quote === '"' || quote === "'") && value.at(-1) === quote ? value.slice(1, -1) : value;
+  if (!powershell)
+    return expandKnownDirectory(text);
+  return expandKnownDirectory(text.replace(/\$\{env:([^}]+)\}/gi, (_, key) => environment(key) ?? "").replace(/\$env:([A-Za-z_][A-Za-z0-9_]*)/gi, (_, key) => environment(key) ?? "").replace(/\$(HOME|PWD|PSHOME)(?=$|[\\/])/gi, (_, key) => {
+    if (key.toUpperCase() === "HOME")
+      return os.homedir();
+    if (key.toUpperCase() === "PWD")
+      return cwd;
+    return path.dirname(shell);
+  }));
+}
+function expandKnownDirectory(value) {
+  if (value.includes("$") || value.includes("`") || value.startsWith("("))
+    return;
+  if (value === "~")
+    return os.homedir();
+  if (value.startsWith("~/") || process.platform === "win32" && value.startsWith("~\\")) {
+    return path.join(os.homedir(), value.slice(2));
+  }
+  return value;
+}
+function environment(key) {
+  if (process.platform !== "win32")
+    return process.env[key];
+  const name = Object.keys(process.env).find((item) => item.toLowerCase() === key.toLowerCase());
+  return name ? process.env[name] : undefined;
+}
+function prefix(tokens) {
+  for (let length = tokens.length;length > 0; length--) {
+    const arity = ARITY[tokens.slice(0, length).join(" ")];
+    if (arity !== undefined)
+      return tokens.slice(0, arity);
+  }
+  return tokens.slice(0, 1);
+}
+function resolve(asset) {
+  if (asset.startsWith("file://"))
+    return fileURLToPath(asset);
+  if (path.isAbsolute(asset))
+    return asset;
+  return fileURLToPath(new URL(asset, import.meta.url));
+}
+var load = lazy2(initialize);
+async function initialize() {
+  const { Parser, Language } = await import("web-tree-sitter");
+  await Parser.init({ locateFile: () => resolve(shellParserWasm.runtime) });
+  const [bashLanguage, psLanguage] = await Promise.all([
+    Language.load(resolve(shellParserWasm.bash)),
+    Language.load(resolve(shellParserWasm.powershell))
+  ]);
+  const bash = new Parser;
+  bash.setLanguage(bashLanguage);
+  const ps = new Parser;
+  ps.setLanguage(psLanguage);
+  return { bash, ps };
+}
+
+export { scan2, scanPortable2, exports_parse };