lody 0.76.0 → 0.77.0

package/dist/chunks/{package-C-zjBee4.js → package-qnDHmQq4.js}

@@ -1,4 +1,4 @@
-import { c as array, u as unknown, N as NEVER, e as union, n as number, s as string, o as object, r as record, G as int, l as literal, b as boolean, y as intersection, H as url } from "./schemas-DAtmu1t9.js";
+import { c as array, u as unknown, N as NEVER, f as union, n as number, s as string, o as object, r as record, H as int, l as literal, b as boolean, z as intersection, I as url } from "./schemas-Du3qLZPS.js";
 const AGENT_METHODS = {
   initialize: "initialize",
   authenticate: "authenticate",
@@ -4114,7 +4114,7 @@ class ClientSideConnection {
   }
 }
 const name = "acp-extension-claude";
-const version = "0.62.0";
+const version = "0.66.0";
 const dependencies = { "@anthropic-ai/claude-agent-sdk": "0.3.220" };
 const packageJson = {
   name,

package/dist/chunks/review-viewer-DchNTv12.js

@@ -0,0 +1,154 @@
+import { createHash } from "node:crypto";
+import { readFile, mkdir, writeFile, rename } from "node:fs/promises";
+import path__default from "node:path";
+import process from "node:process";
+import { g as getLodyDataDir, __tla as __tla_0 } from "../index.js";
+import "path";
+import "node:fs";
+import "node:readline";
+import "node:async_hooks";
+import "fs";
+import "crypto";
+import "node:os";
+import "./schemas-Du3qLZPS.js";
+import "node:events";
+import "node:child_process";
+import "node:tty";
+import "os";
+import "util";
+import "stream";
+import "buffer";
+import "events";
+import "zlib";
+import "tty";
+import "string_decoder";
+import "http";
+import "https";
+import "node:util";
+import "node:zlib";
+import "child_process";
+import "perf_hooks";
+import "net";
+import "tls";
+import "url";
+import { __tla as __tla_1 } from "./loro_wasm_bg-BuoLmEH-.js";
+import "assert";
+import "fs/promises";
+import "better-sqlite3";
+import "node:diagnostics_channel";
+import "node:assert";
+import "node:net";
+import "node:http";
+import "node:stream";
+import "node:buffer";
+import "node:querystring";
+import "node:tls";
+import "node:perf_hooks";
+import "node:util/types";
+import "node:worker_threads";
+import "node:url";
+import "node:console";
+import "node:dns";
+import "./directory-handle-BBQKxZ5F.js";
+import "./diff-line-counts-bmGB_T-n.js";
+import "./package-qnDHmQq4.js";
+import "node:string_decoder";
+import "node:stream/promises";
+import "async_hooks";
+import "module";
+import "./diff-worker-task-8tVIjLTu.js";
+import "./workspace-watch-protocol-CSO-IQeE.js";
+import "node:module";
+import "node:v8";
+let resolveReviewViewerTemplate;
+let __tla = Promise.all([
+  (() => {
+    try {
+      return __tla_0;
+    } catch {
+    }
+  })(),
+  (() => {
+    try {
+      return __tla_1;
+    } catch {
+    }
+  })()
+]).then(async () => {
+  const reviewViewerVersion = "0.77.0";
+  const reviewViewerSha256 = "41b6ffd0acff2c355e190b604776a89138f9598a1772d09390a6d5af514e71bb";
+  const reviewViewerFileName = "standalone.html";
+  const DEFAULT_CDN_BASES = [
+    "https://cdn.jsdelivr.net/npm",
+    "https://unpkg.com"
+  ];
+  function cacheDir() {
+    return path__default.join(getLodyDataDir(), "code-review-viewer");
+  }
+  function cachePath() {
+    return path__default.join(cacheDir(), `${reviewViewerVersion}.html`);
+  }
+  function sha256(buffer) {
+    return createHash("sha256").update(buffer).digest("hex");
+  }
+  function isUrl(source) {
+    return /^https?:\/\//i.test(source);
+  }
+  async function loadSource(source) {
+    if (isUrl(source)) {
+      const response = await fetch(source, {
+        signal: AbortSignal.timeout(3e4)
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      return Buffer.from(await response.arrayBuffer());
+    }
+    return readFile(path__default.resolve(source));
+  }
+  async function writeCache(buffer) {
+    try {
+      await mkdir(cacheDir(), {
+        recursive: true
+      });
+      const tmp = `${cachePath()}.tmp-${process.pid}`;
+      await writeFile(tmp, buffer);
+      await rename(tmp, cachePath());
+    } catch {
+    }
+  }
+  resolveReviewViewerTemplate = async function() {
+    try {
+      const cached = await readFile(cachePath());
+      if (sha256(cached) === reviewViewerSha256) {
+        return cached.toString("utf8");
+      }
+    } catch {
+    }
+    const override = process.env.LODY_REVIEW_VIEWER?.trim();
+    const sources = override ? [
+      override
+    ] : DEFAULT_CDN_BASES.map((base) => `${base}/lody-code-review-viewer@${reviewViewerVersion}/${reviewViewerFileName}`);
+    const failures = [];
+    for (const source of sources) {
+      try {
+        const buffer = await loadSource(source);
+        const actual = sha256(buffer);
+        if (actual !== reviewViewerSha256) {
+          failures.push(`${source}: sha256 mismatch (expected ${reviewViewerSha256.slice(0, 12)}\u2026, got ${actual.slice(0, 12)}\u2026)`);
+          continue;
+        }
+        await writeCache(buffer);
+        return buffer.toString("utf8");
+      } catch (error) {
+        failures.push(`${source}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    throw new Error(`Could not obtain the code-review viewer (lody-code-review-viewer@${reviewViewerVersion}).
+` + failures.map((line) => `  - ${line}`).join("\n") + "\nIf you are offline or behind a firewall, download standalone.html for this version and point LODY_REVIEW_VIEWER at it (a file path or URL).");
+  };
+});
+export {
+  __tla,
+  resolveReviewViewerTemplate
+};

package/dist/chunks/{schemas-DAtmu1t9.js → schemas-Du3qLZPS.js}

@@ -4828,20 +4828,43 @@ function refine(fn, _params = {}) {
 function superRefine(fn) {
   return /* @__PURE__ */ _superRefine(fn);
 }
+function _instanceof(cls, params = {}) {
+  const inst = new ZodCustom({
+    type: "custom",
+    check: "custom",
+    fn: (data) => data instanceof cls,
+    abort: true,
+    ...normalizeParams(params)
+  });
+  inst._zod.bag.Class = cls;
+  inst._zod.check = (payload) => {
+    if (!(payload.value instanceof cls)) {
+      payload.issues.push({
+        code: "invalid_type",
+        expected: cls.name,
+        input: payload.value,
+        inst,
+        path: [...inst._zod.def.path ?? []]
+      });
+    }
+  };
+  return inst;
+}
 function preprocess(fn, schema) {
   return pipe(transform(fn), schema);
 }
 export {
   $constructor as $,
-  datetime as A,
-  custom as B,
-  toJSONSchema as C,
-  ZodOptional as D,
-  never as E,
-  xor as F,
-  int as G,
-  url as H,
-  tuple as I,
+  optional as A,
+  datetime as B,
+  custom as C,
+  toJSONSchema as D,
+  ZodOptional as E,
+  never as F,
+  xor as G,
+  int as H,
+  url as I,
+  tuple as J,
   NEVER as N,
   ZodNumber as Z,
   _coercedNumber as _,
@@ -4849,26 +4872,26 @@ export {
   boolean as b,
   array as c,
   discriminatedUnion as d,
-  union as e,
-  ZodError as f,
-  _null as g,
-  normalizeParams as h,
-  $ZodObject as i,
-  defineLazy as j,
-  $ZodType as k,
+  _instanceof as e,
+  union as f,
+  ZodError as g,
+  _null as h,
+  normalizeParams as i,
+  $ZodObject as j,
+  defineLazy as k,
   literal as l,
-  parse$1 as m,
+  $ZodType as m,
   number as n,
   object as o,
   preprocess as p,
-  safeParse$1 as q,
+  parse$1 as q,
   record as r,
   string as s,
-  parseAsync$1 as t,
+  safeParse$1 as t,
   unknown as u,
-  safeParseAsync$1 as v,
-  clone as w,
-  looseObject as x,
-  intersection as y,
-  optional as z
+  parseAsync$1 as v,
+  safeParseAsync$1 as w,
+  clone as x,
+  looseObject as y,
+  intersection as z
 };