@opencode/browse 0.0.6 → 0.0.8-dev.36

package/dist/main-brs53cap.mjs

@@ -0,0 +1,205 @@
+import {
+  succeed,
+  fail,
+  isResult,
+  isSuccess,
+  ClockRef,
+  currentTimeMillis
+} from "./main-9z6jbwdp.mjs";
+import {
+  pipeArguments,
+  identity
+} from "./main-yf9xhpn4.mjs";
+
+// node_modules/effect/dist/Clock.js
+var Clock = ClockRef;
+var currentTimeMillis2 = currentTimeMillis;
+
+// node_modules/effect/dist/internal/matcher.js
+var TypeId = "~effect/Match/Matcher";
+var TypeMatcherProto = {
+  [TypeId]: {
+    _input: identity,
+    _filters: identity,
+    _remaining: identity,
+    _result: identity,
+    _return: identity,
+    _args: identity
+  },
+  _tag: "TypeMatcher",
+  add(_case) {
+    return makeTypeMatcher(this.select, [...this.cases, _case]);
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+function makeTypeMatcher(select, cases) {
+  const matcher = Object.create(TypeMatcherProto);
+  matcher.select = select;
+  matcher.cases = cases;
+  return matcher;
+}
+var ValueMatcherProto = {
+  [TypeId]: {
+    _input: identity,
+    _filters: identity,
+    _result: identity,
+    _return: identity,
+    _flavor: identity
+  },
+  _tag: "ValueMatcher",
+  add(_case) {
+    if (isSuccess(this.value)) {
+      return this;
+    }
+    if (_case._tag === "When" && _case.guard(this.provided) === true) {
+      return makeValueMatcher(this.provided, succeed(_case.evaluate(this.provided)));
+    } else if (_case._tag === "Not" && _case.guard(this.provided) === false) {
+      return makeValueMatcher(this.provided, succeed(_case.evaluate(this.provided)));
+    }
+    return this;
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+function makeValueMatcher(provided, value) {
+  const matcher = Object.create(ValueMatcherProto);
+  matcher.provided = provided;
+  matcher.value = value;
+  return matcher;
+}
+var makeWhen = (guard, evaluate) => ({
+  _tag: "When",
+  guard,
+  evaluate
+});
+var makePredicate = (pattern) => {
+  if (typeof pattern === "function") {
+    return pattern;
+  } else if (Array.isArray(pattern)) {
+    const predicates = pattern.map(makePredicate);
+    const len = predicates.length;
+    return (u) => {
+      if (!Array.isArray(u)) {
+        return false;
+      }
+      for (let i = 0;i < len; i++) {
+        if (predicates[i](u[i]) === false) {
+          return false;
+        }
+      }
+      return true;
+    };
+  } else if (pattern !== null && typeof pattern === "object") {
+    const keysAndPredicates = Reflect.ownKeys(pattern).map((key) => [key, makePredicate(pattern[key])]);
+    const len = keysAndPredicates.length;
+    return (u) => {
+      if (typeof u !== "object" || u === null) {
+        return false;
+      }
+      for (let i = 0;i < len; i++) {
+        const [key, predicate] = keysAndPredicates[i];
+        if (!(key in u) || predicate(u[key]) === false) {
+          return false;
+        }
+      }
+      return true;
+    };
+  }
+  return (u) => u === pattern;
+};
+var value = (i) => makeValueMatcher(i, fail(i));
+var when = (pattern, f) => (self) => self.add(makeWhen(makePredicate(pattern), f));
+var discriminator = (field) => (...pattern) => {
+  const f = pattern[pattern.length - 1];
+  const values = pattern.slice(0, -1);
+  const pred = values.length === 1 ? (_) => _ != null && _[field] === values[0] : (_) => _ != null && values.includes(_[field]);
+  return (self) => self.add(makeWhen(pred, f));
+};
+var discriminators = (field) => (fields) => {
+  const predicate = makeWhen((arg) => arg != null && Object.hasOwn(fields, arg[field]), (data) => fields[data[field]](data));
+  return (self) => self.add(predicate);
+};
+var tag = /* @__PURE__ */ discriminator("_tag");
+var tags2 = /* @__PURE__ */ discriminators("_tag");
+var is = (...literals) => {
+  const len = literals.length;
+  return (u) => {
+    for (let i = 0;i < len; i++) {
+      if (u === literals[i]) {
+        return true;
+      }
+    }
+    return false;
+  };
+};
+var orElse2 = (f) => (self) => {
+  const toResult = result(self);
+  if (isResult(toResult)) {
+    return toResult._tag === "Success" ? toResult.success : f(toResult.failure);
+  }
+  return (...args) => {
+    const a = toResult(...args);
+    return isSuccess(a) ? a.success : f(a.failure, ...args);
+  };
+};
+var result = (self) => {
+  if (self._tag === "ValueMatcher") {
+    return self.value;
+  }
+  const len = self.cases.length;
+  if (len === 1) {
+    const _case = self.cases[0];
+    return (...args) => {
+      const input = self.select(...args);
+      if (_case._tag === "When" && _case.guard(input) === true) {
+        return succeed(_case.evaluate(input, ...args));
+      } else if (_case._tag === "Not" && _case.guard(input) === false) {
+        return succeed(_case.evaluate(input, ...args));
+      }
+      return fail(input);
+    };
+  }
+  return (...args) => {
+    const input = self.select(...args);
+    for (let i = 0;i < len; i++) {
+      const _case = self.cases[i];
+      if (_case._tag === "When" && _case.guard(input) === true) {
+        return succeed(_case.evaluate(input, ...args));
+      } else if (_case._tag === "Not" && _case.guard(input) === false) {
+        return succeed(_case.evaluate(input, ...args));
+      }
+    }
+    return fail(input);
+  };
+};
+var getExhaustiveAbsurdErrorMessage = "effect/match/Match/exhaustive: absurd";
+var exhaustive2 = (self) => {
+  const toResult = result(self);
+  if (isResult(toResult)) {
+    if (isSuccess(toResult)) {
+      return toResult.success;
+    }
+    throw new Error(getExhaustiveAbsurdErrorMessage);
+  }
+  return (...args) => {
+    const result = toResult(...args);
+    if (isSuccess(result)) {
+      return result.success;
+    }
+    throw new Error(getExhaustiveAbsurdErrorMessage);
+  };
+};
+
+// node_modules/effect/dist/Match.js
+var value2 = value;
+var when2 = when;
+var tag2 = tag;
+var tags = tags2;
+var is2 = is;
+var orElse = orElse2;
+var exhaustive = exhaustive2;
+
+export { Clock, currentTimeMillis2, value2, when2, tag2, tags, is2, orElse, exhaustive };

package/dist/{main-yv64m9we.mjs → main-evpvxp5p.mjs}

@@ -1,14 +1,15 @@
 import {
   dataRoot
-} from "./main-3cza6vx1.mjs";
-
+} from "./main-0jhjvcrn.mjs";
+import {
+  isString
+} from "./main-yf9xhpn4.mjs";
 // src/relay/secrets.ts
 import crypto2 from "node:crypto";
 import fs2 from "node:fs";
 import path2 from "node:path";
 
 // src/fs-durability.ts
-import { Predicate } from "effect";
 import crypto from "node:crypto";
 import fsSync from "node:fs";
 import fs from "node:fs/promises";
@@ -18,7 +19,7 @@ function isNodeError(error) {
   return error instanceof Error && "code" in error;
 }
 function isUnsupportedDirectorySyncError(error) {
-  return isNodeError(error) && Predicate.isString(error.code) && unsupportedDirectorySyncCodes.has(error.code);
+  return isNodeError(error) && isString(error.code) && unsupportedDirectorySyncCodes.has(error.code);
 }
 async function writeJsonFileAtomically(filePath, value, options = {}) {
   const directory = path.dirname(filePath);

package/dist/main-g25csbpx.mjs

@@ -0,0 +1,4 @@
+// src/version.ts
+var opencodeBrowserVersion2 = "0.0.8-dev.36";
+var opencodeBrowserBuildId2 = "2026-11-04T22:45:48.392Z";
+export { opencodeBrowserVersion2, opencodeBrowserBuildId2 };

package/dist/{main-q5j1am67.mjs → main-jqady4pw.mjs}

@@ -6,7 +6,7 @@ import {
   compareVersions,
   npmRuntime,
   autoUpdateStatus
-} from "./main-3cza6vx1.mjs";
+} from "./main-0jhjvcrn.mjs";
 import {
   unpackedReloadAdvice
 } from "./main-3gthmkzw.mjs";
@@ -315,7 +315,7 @@ function runUpdate(args, deps) {
 async function runUpdateCommand2(args) {
   const log = (line) => process.stdout.write(line + `
 `);
-  const { runNpmUpdate } = await import("./runtime-update-zjx0kaj7.mjs");
+  const { runNpmUpdate } = await import("./runtime-update-njmqcdep.mjs");
   if (await runNpmUpdate(args))
     return;
   if (compiledBinary()) {