@hasna/files 0.2.0 → 0.2.1

package/dist/mcp/index.js

@@ -479,6 +479,10 @@ function listFiles(opts = {}) {
     conditions.push("f.machine_id = ?");
     params.push(opts.machine_id);
   }
+  if (opts.sync_status) {
+    conditions.push("f.sync_status = ?");
+    params.push(opts.sync_status);
+  }
   if (opts.ext) {
     conditions.push("f.ext = ?");
     params.push(opts.ext.startsWith(".") ? opts.ext : `.${opts.ext}`);
@@ -10029,6 +10033,464 @@ var init_mime_types = __esm(() => {
   populateMaps($extensions, $types);
 });
 
+// node_modules/@noble/hashes/esm/utils.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function anumber(n) {
+  if (!Number.isSafeInteger(n) || n < 0)
+    throw new Error("positive integer expected, got " + n);
+}
+function abytes(b, ...lengths) {
+  if (!isBytes(b))
+    throw new Error("Uint8Array expected");
+  if (lengths.length > 0 && !lengths.includes(b.length))
+    throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+}
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function aoutput(out, instance) {
+  abytes(out);
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error("digestInto() expects output buffer of length at least " + min);
+  }
+}
+function u8(arr) {
+  return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function u32(arr) {
+  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+}
+function clean(...arrays) {
+  for (let i = 0;i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+function rotr(word, shift) {
+  return word << 32 - shift | word >>> shift;
+}
+function byteSwap(word) {
+  return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+}
+function byteSwap32(arr) {
+  for (let i = 0;i < arr.length; i++) {
+    arr[i] = byteSwap(arr[i]);
+  }
+  return arr;
+}
+function utf8ToBytes(str) {
+  if (typeof str !== "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+function toBytes(data) {
+  if (typeof data === "string")
+    data = utf8ToBytes(data);
+  abytes(data);
+  return data;
+}
+
+class Hash {
+}
+function createXOFer(hashCons) {
+  const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+  const tmp = hashCons({});
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = (opts) => hashCons(opts);
+  return hashC;
+}
+var isLE, swap8IfBE, swap32IfBE;
+var init_utils = __esm(() => {
+  /*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+  isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+  swap8IfBE = isLE ? (n) => n : (n) => byteSwap(n);
+  swap32IfBE = isLE ? (u) => u : byteSwap32;
+});
+
+// node_modules/@noble/hashes/esm/_md.js
+var SHA256_IV;
+var init__md = __esm(() => {
+  SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ]);
+});
+
+// node_modules/@noble/hashes/esm/_u64.js
+function fromBig(n, le = false) {
+  if (le)
+    return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
+  return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+}
+var U32_MASK64, _32n;
+var init__u64 = __esm(() => {
+  U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+  _32n = /* @__PURE__ */ BigInt(32);
+});
+
+// node_modules/@noble/hashes/esm/_blake.js
+function G1s(a, b, c, d, x) {
+  a = a + b + x | 0;
+  d = rotr(d ^ a, 16);
+  c = c + d | 0;
+  b = rotr(b ^ c, 12);
+  return { a, b, c, d };
+}
+function G2s(a, b, c, d, x) {
+  a = a + b + x | 0;
+  d = rotr(d ^ a, 8);
+  c = c + d | 0;
+  b = rotr(b ^ c, 7);
+  return { a, b, c, d };
+}
+var init__blake = __esm(() => {
+  init_utils();
+});
+
+// node_modules/@noble/hashes/esm/blake2.js
+function compress(s, offset, msg, rounds, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) {
+  let j = 0;
+  for (let i = 0;i < rounds; i++) {
+    ({ a: v0, b: v4, c: v8, d: v12 } = G1s(v0, v4, v8, v12, msg[offset + s[j++]]));
+    ({ a: v0, b: v4, c: v8, d: v12 } = G2s(v0, v4, v8, v12, msg[offset + s[j++]]));
+    ({ a: v1, b: v5, c: v9, d: v13 } = G1s(v1, v5, v9, v13, msg[offset + s[j++]]));
+    ({ a: v1, b: v5, c: v9, d: v13 } = G2s(v1, v5, v9, v13, msg[offset + s[j++]]));
+    ({ a: v2, b: v6, c: v10, d: v14 } = G1s(v2, v6, v10, v14, msg[offset + s[j++]]));
+    ({ a: v2, b: v6, c: v10, d: v14 } = G2s(v2, v6, v10, v14, msg[offset + s[j++]]));
+    ({ a: v3, b: v7, c: v11, d: v15 } = G1s(v3, v7, v11, v15, msg[offset + s[j++]]));
+    ({ a: v3, b: v7, c: v11, d: v15 } = G2s(v3, v7, v11, v15, msg[offset + s[j++]]));
+    ({ a: v0, b: v5, c: v10, d: v15 } = G1s(v0, v5, v10, v15, msg[offset + s[j++]]));
+    ({ a: v0, b: v5, c: v10, d: v15 } = G2s(v0, v5, v10, v15, msg[offset + s[j++]]));
+    ({ a: v1, b: v6, c: v11, d: v12 } = G1s(v1, v6, v11, v12, msg[offset + s[j++]]));
+    ({ a: v1, b: v6, c: v11, d: v12 } = G2s(v1, v6, v11, v12, msg[offset + s[j++]]));
+    ({ a: v2, b: v7, c: v8, d: v13 } = G1s(v2, v7, v8, v13, msg[offset + s[j++]]));
+    ({ a: v2, b: v7, c: v8, d: v13 } = G2s(v2, v7, v8, v13, msg[offset + s[j++]]));
+    ({ a: v3, b: v4, c: v9, d: v14 } = G1s(v3, v4, v9, v14, msg[offset + s[j++]]));
+    ({ a: v3, b: v4, c: v9, d: v14 } = G2s(v3, v4, v9, v14, msg[offset + s[j++]]));
+  }
+  return { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 };
+}
+var BLAKE2;
+var init_blake2 = __esm(() => {
+  init__blake();
+  init_utils();
+  BLAKE2 = class BLAKE2 extends Hash {
+    constructor(blockLen, outputLen) {
+      super();
+      this.finished = false;
+      this.destroyed = false;
+      this.length = 0;
+      this.pos = 0;
+      anumber(blockLen);
+      anumber(outputLen);
+      this.blockLen = blockLen;
+      this.outputLen = outputLen;
+      this.buffer = new Uint8Array(blockLen);
+      this.buffer32 = u32(this.buffer);
+    }
+    update(data) {
+      aexists(this);
+      data = toBytes(data);
+      abytes(data);
+      const { blockLen, buffer, buffer32 } = this;
+      const len = data.length;
+      const offset = data.byteOffset;
+      const buf = data.buffer;
+      for (let pos = 0;pos < len; ) {
+        if (this.pos === blockLen) {
+          swap32IfBE(buffer32);
+          this.compress(buffer32, 0, false);
+          swap32IfBE(buffer32);
+          this.pos = 0;
+        }
+        const take = Math.min(blockLen - this.pos, len - pos);
+        const dataOffset = offset + pos;
+        if (take === blockLen && !(dataOffset % 4) && pos + take < len) {
+          const data32 = new Uint32Array(buf, dataOffset, Math.floor((len - pos) / 4));
+          swap32IfBE(data32);
+          for (let pos32 = 0;pos + blockLen < len; pos32 += buffer32.length, pos += blockLen) {
+            this.length += blockLen;
+            this.compress(data32, pos32, false);
+          }
+          swap32IfBE(data32);
+          continue;
+        }
+        buffer.set(data.subarray(pos, pos + take), this.pos);
+        this.pos += take;
+        this.length += take;
+        pos += take;
+      }
+      return this;
+    }
+    digestInto(out) {
+      aexists(this);
+      aoutput(out, this);
+      const { pos, buffer32 } = this;
+      this.finished = true;
+      clean(this.buffer.subarray(pos));
+      swap32IfBE(buffer32);
+      this.compress(buffer32, 0, true);
+      swap32IfBE(buffer32);
+      const out32 = u32(out);
+      this.get().forEach((v, i) => out32[i] = swap8IfBE(v));
+    }
+    digest() {
+      const { buffer, outputLen } = this;
+      this.digestInto(buffer);
+      const res = buffer.slice(0, outputLen);
+      this.destroy();
+      return res;
+    }
+    _cloneInto(to) {
+      const { buffer, length, finished, destroyed, outputLen, pos } = this;
+      to || (to = new this.constructor({ dkLen: outputLen }));
+      to.set(...this.get());
+      to.buffer.set(buffer);
+      to.destroyed = destroyed;
+      to.finished = finished;
+      to.length = length;
+      to.pos = pos;
+      to.outputLen = outputLen;
+      return to;
+    }
+    clone() {
+      return this._cloneInto();
+    }
+  };
+});
+
+// node_modules/@noble/hashes/esm/blake3.js
+var B3_Flags, B3_IV, B3_SIGMA, BLAKE3, blake3;
+var init_blake3 = __esm(() => {
+  init__md();
+  init__u64();
+  init_blake2();
+  init_utils();
+  B3_Flags = {
+    CHUNK_START: 1,
+    CHUNK_END: 2,
+    PARENT: 4,
+    ROOT: 8,
+    KEYED_HASH: 16,
+    DERIVE_KEY_CONTEXT: 32,
+    DERIVE_KEY_MATERIAL: 64
+  };
+  B3_IV = SHA256_IV.slice();
+  B3_SIGMA = /* @__PURE__ */ (() => {
+    const Id = Array.from({ length: 16 }, (_, i) => i);
+    const permute = (arr) => [2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8].map((i) => arr[i]);
+    const res = [];
+    for (let i = 0, v = Id;i < 7; i++, v = permute(v))
+      res.push(...v);
+    return Uint8Array.from(res);
+  })();
+  BLAKE3 = class BLAKE3 extends BLAKE2 {
+    constructor(opts = {}, flags = 0) {
+      super(64, opts.dkLen === undefined ? 32 : opts.dkLen);
+      this.chunkPos = 0;
+      this.chunksDone = 0;
+      this.flags = 0 | 0;
+      this.stack = [];
+      this.posOut = 0;
+      this.bufferOut32 = new Uint32Array(16);
+      this.chunkOut = 0;
+      this.enableXOF = true;
+      const { key, context } = opts;
+      const hasContext = context !== undefined;
+      if (key !== undefined) {
+        if (hasContext)
+          throw new Error('Only "key" or "context" can be specified at same time');
+        const k = toBytes(key).slice();
+        abytes(k, 32);
+        this.IV = u32(k);
+        swap32IfBE(this.IV);
+        this.flags = flags | B3_Flags.KEYED_HASH;
+      } else if (hasContext) {
+        const ctx = toBytes(context);
+        const contextKey = new BLAKE3({ dkLen: 32 }, B3_Flags.DERIVE_KEY_CONTEXT).update(ctx).digest();
+        this.IV = u32(contextKey);
+        swap32IfBE(this.IV);
+        this.flags = flags | B3_Flags.DERIVE_KEY_MATERIAL;
+      } else {
+        this.IV = B3_IV.slice();
+        this.flags = flags;
+      }
+      this.state = this.IV.slice();
+      this.bufferOut = u8(this.bufferOut32);
+    }
+    get() {
+      return [];
+    }
+    set() {}
+    b2Compress(counter, flags, buf, bufPos = 0) {
+      const { state: s, pos } = this;
+      const { h, l } = fromBig(BigInt(counter), true);
+      const { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 } = compress(B3_SIGMA, bufPos, buf, 7, s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], B3_IV[0], B3_IV[1], B3_IV[2], B3_IV[3], h, l, pos, flags);
+      s[0] = v0 ^ v8;
+      s[1] = v1 ^ v9;
+      s[2] = v2 ^ v10;
+      s[3] = v3 ^ v11;
+      s[4] = v4 ^ v12;
+      s[5] = v5 ^ v13;
+      s[6] = v6 ^ v14;
+      s[7] = v7 ^ v15;
+    }
+    compress(buf, bufPos = 0, isLast = false) {
+      let flags = this.flags;
+      if (!this.chunkPos)
+        flags |= B3_Flags.CHUNK_START;
+      if (this.chunkPos === 15 || isLast)
+        flags |= B3_Flags.CHUNK_END;
+      if (!isLast)
+        this.pos = this.blockLen;
+      this.b2Compress(this.chunksDone, flags, buf, bufPos);
+      this.chunkPos += 1;
+      if (this.chunkPos === 16 || isLast) {
+        let chunk = this.state;
+        this.state = this.IV.slice();
+        for (let last, chunks = this.chunksDone + 1;isLast || !(chunks & 1); chunks >>= 1) {
+          if (!(last = this.stack.pop()))
+            break;
+          this.buffer32.set(last, 0);
+          this.buffer32.set(chunk, 8);
+          this.pos = this.blockLen;
+          this.b2Compress(0, this.flags | B3_Flags.PARENT, this.buffer32, 0);
+          chunk = this.state;
+          this.state = this.IV.slice();
+        }
+        this.chunksDone++;
+        this.chunkPos = 0;
+        this.stack.push(chunk);
+      }
+      this.pos = 0;
+    }
+    _cloneInto(to) {
+      to = super._cloneInto(to);
+      const { IV, flags, state, chunkPos, posOut, chunkOut, stack, chunksDone } = this;
+      to.state.set(state.slice());
+      to.stack = stack.map((i) => Uint32Array.from(i));
+      to.IV.set(IV);
+      to.flags = flags;
+      to.chunkPos = chunkPos;
+      to.chunksDone = chunksDone;
+      to.posOut = posOut;
+      to.chunkOut = chunkOut;
+      to.enableXOF = this.enableXOF;
+      to.bufferOut32.set(this.bufferOut32);
+      return to;
+    }
+    destroy() {
+      this.destroyed = true;
+      clean(this.state, this.buffer32, this.IV, this.bufferOut32);
+      clean(...this.stack);
+    }
+    b2CompressOut() {
+      const { state: s, pos, flags, buffer32, bufferOut32: out32 } = this;
+      const { h, l } = fromBig(BigInt(this.chunkOut++));
+      swap32IfBE(buffer32);
+      const { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 } = compress(B3_SIGMA, 0, buffer32, 7, s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], B3_IV[0], B3_IV[1], B3_IV[2], B3_IV[3], l, h, pos, flags);
+      out32[0] = v0 ^ v8;
+      out32[1] = v1 ^ v9;
+      out32[2] = v2 ^ v10;
+      out32[3] = v3 ^ v11;
+      out32[4] = v4 ^ v12;
+      out32[5] = v5 ^ v13;
+      out32[6] = v6 ^ v14;
+      out32[7] = v7 ^ v15;
+      out32[8] = s[0] ^ v8;
+      out32[9] = s[1] ^ v9;
+      out32[10] = s[2] ^ v10;
+      out32[11] = s[3] ^ v11;
+      out32[12] = s[4] ^ v12;
+      out32[13] = s[5] ^ v13;
+      out32[14] = s[6] ^ v14;
+      out32[15] = s[7] ^ v15;
+      swap32IfBE(buffer32);
+      swap32IfBE(out32);
+      this.posOut = 0;
+    }
+    finish() {
+      if (this.finished)
+        return;
+      this.finished = true;
+      clean(this.buffer.subarray(this.pos));
+      let flags = this.flags | B3_Flags.ROOT;
+      if (this.stack.length) {
+        flags |= B3_Flags.PARENT;
+        swap32IfBE(this.buffer32);
+        this.compress(this.buffer32, 0, true);
+        swap32IfBE(this.buffer32);
+        this.chunksDone = 0;
+        this.pos = this.blockLen;
+      } else {
+        flags |= (!this.chunkPos ? B3_Flags.CHUNK_START : 0) | B3_Flags.CHUNK_END;
+      }
+      this.flags = flags;
+      this.b2CompressOut();
+    }
+    writeInto(out) {
+      aexists(this, false);
+      abytes(out);
+      this.finish();
+      const { blockLen, bufferOut } = this;
+      for (let pos = 0, len = out.length;pos < len; ) {
+        if (this.posOut >= blockLen)
+          this.b2CompressOut();
+        const take = Math.min(blockLen - this.posOut, len - pos);
+        out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+        this.posOut += take;
+        pos += take;
+      }
+      return out;
+    }
+    xofInto(out) {
+      if (!this.enableXOF)
+        throw new Error("XOF is not possible after digest call");
+      return this.writeInto(out);
+    }
+    xof(bytes) {
+      anumber(bytes);
+      return this.xofInto(new Uint8Array(bytes));
+    }
+    digestInto(out) {
+      aoutput(out, this);
+      if (this.finished)
+        throw new Error("digest() was already called");
+      this.enableXOF = false;
+      this.writeInto(out);
+      this.destroy();
+      return out;
+    }
+    digest() {
+      return this.digestInto(new Uint8Array(this.outputLen));
+    }
+  };
+  blake3 = /* @__PURE__ */ createXOFer((opts) => new BLAKE3(opts));
+});
+
+// src/lib/hasher.ts
+import { readFileSync as readFileSync2 } from "fs";
+function hashFile(filePath) {
+  const data = readFileSync2(filePath);
+  const hash = blake3(data);
+  return Buffer.from(hash).toString("hex");
+}
+var init_hasher = __esm(() => {
+  init_blake3();
+});
+
 // node_modules/@smithy/types/dist-cjs/index.js
 var require_dist_cjs = __commonJS((exports) => {
   exports.HttpAuthLocation = undefined;
@@ -42837,7 +43299,7 @@ var validateWaiterOptions = (options) => {
 };
 
 // node_modules/@smithy/util-waiter/dist-es/utils/index.js
-var init_utils = () => {};
+var init_utils2 = () => {};
 
 // node_modules/@smithy/util-waiter/dist-es/createWaiter.js
 var abortTimeout = (abortSignal) => {
@@ -42885,7 +43347,7 @@ var abortTimeout = (abortSignal) => {
 };
 var init_createWaiter = __esm(() => {
   init_poller();
-  init_utils();
+  init_utils2();
   init_waiter();
 });
 
@@ -42909,6 +43371,9 @@ var checkState = async (client, input) => {
     }
   }
   return { state: WaiterState.RETRY, reason };
+}, waitForBucketExists = async (params, input) => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 }, waitUntilBucketExists = async (params, input) => {
   const serviceDefaults = { minDelay: 5, maxDelay: 120 };
   const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
@@ -42932,6 +43397,9 @@ var checkState2 = async (client, input) => {
     }
   }
   return { state: WaiterState.RETRY, reason };
+}, waitForBucketNotExists = async (params, input) => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  return createWaiter({ ...serviceDefaults, ...params }, input, checkState2);
 }, waitUntilBucketNotExists = async (params, input) => {
   const serviceDefaults = { minDelay: 5, maxDelay: 120 };
   const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState2);
@@ -42956,6 +43424,9 @@ var checkState3 = async (client, input) => {
     }
   }
   return { state: WaiterState.RETRY, reason };
+}, waitForObjectExists = async (params, input) => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  return createWaiter({ ...serviceDefaults, ...params }, input, checkState3);
 }, waitUntilObjectExists = async (params, input) => {
   const serviceDefaults = { minDelay: 5, maxDelay: 120 };
   const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState3);
@@ -42979,6 +43450,9 @@ var checkState4 = async (client, input) => {
     }
   }
   return { state: WaiterState.RETRY, reason };
+}, waitForObjectNotExists = async (params, input) => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  return createWaiter({ ...serviceDefaults, ...params }, input, checkState4);
 }, waitUntilObjectNotExists = async (params, input) => {
   const serviceDefaults = { minDelay: 5, maxDelay: 120 };
   const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState4);
@@ -43367,8 +43841,56 @@ var init_waiters = __esm(() => {
 });
 
 // node_modules/@aws-sdk/client-s3/dist-es/models/enums.js
-var ChecksumAlgorithm2;
+var BucketAbacStatus, RequestCharged, RequestPayer, BucketAccelerateStatus, Type, Permission, OwnerOverride, ChecksumType, ServerSideEncryption, ObjectCannedACL, ChecksumAlgorithm2, MetadataDirective, ObjectLockLegalHoldStatus, ObjectLockMode, StorageClass, TaggingDirective, BucketCannedACL, BucketNamespace, DataRedundancy, BucketType, LocationType, BucketLocationConstraint, ObjectOwnership, InventoryConfigurationState, TableSseAlgorithm, ExpirationState, SessionMode, AnalyticsS3ExportFileFormat, StorageClassAnalysisSchemaVersion, EncryptionType, IntelligentTieringStatus, IntelligentTieringAccessTier, InventoryFormat, InventoryIncludedObjectVersions, InventoryOptionalField, InventoryFrequency, TransitionStorageClass, ExpirationStatus, TransitionDefaultMinimumObjectSize, BucketLogsPermission, PartitionDateSource, S3TablesBucketType, Event, FilterRuleName, DeleteMarkerReplicationStatus, MetricsStatus, ReplicationTimeStatus, ExistingObjectReplicationStatus, ReplicaModificationsStatus, SseKmsEncryptedObjectsStatus, ReplicationRuleStatus, Payer, MFADeleteStatus, BucketVersioningStatus, Protocol, ReplicationStatus, ChecksumMode, ObjectAttributes, ObjectLockEnabled, ObjectLockRetentionMode, ArchiveStatus, EncodingType, ObjectStorageClass, OptionalObjectAttributes, ObjectVersionStorageClass, MFADelete, Tier, ExpressionType, CompressionType, FileHeaderInfo, JSONType, QuoteFields, RestoreRequestType;
 var init_enums = __esm(() => {
+  BucketAbacStatus = {
+    Disabled: "Disabled",
+    Enabled: "Enabled"
+  };
+  RequestCharged = {
+    requester: "requester"
+  };
+  RequestPayer = {
+    requester: "requester"
+  };
+  BucketAccelerateStatus = {
+    Enabled: "Enabled",
+    Suspended: "Suspended"
+  };
+  Type = {
+    AmazonCustomerByEmail: "AmazonCustomerByEmail",
+    CanonicalUser: "CanonicalUser",
+    Group: "Group"
+  };
+  Permission = {
+    FULL_CONTROL: "FULL_CONTROL",
+    READ: "READ",
+    READ_ACP: "READ_ACP",
+    WRITE: "WRITE",
+    WRITE_ACP: "WRITE_ACP"
+  };
+  OwnerOverride = {
+    Destination: "Destination"
+  };
+  ChecksumType = {
+    COMPOSITE: "COMPOSITE",
+    FULL_OBJECT: "FULL_OBJECT"
+  };
+  ServerSideEncryption = {
+    AES256: "AES256",
+    aws_fsx: "aws:fsx",
+    aws_kms: "aws:kms",
+    aws_kms_dsse: "aws:kms:dsse"
+  };
+  ObjectCannedACL = {
+    authenticated_read: "authenticated-read",
+    aws_exec_read: "aws-exec-read",
+    bucket_owner_full_control: "bucket-owner-full-control",
+    bucket_owner_read: "bucket-owner-read",
+    private: "private",
+    public_read: "public-read",
+    public_read_write: "public-read-write"
+  };
   ChecksumAlgorithm2 = {
     CRC32: "CRC32",
     CRC32C: "CRC32C",
@@ -43376,6 +43898,354 @@ var init_enums = __esm(() => {
     SHA1: "SHA1",
     SHA256: "SHA256"
   };
+  MetadataDirective = {
+    COPY: "COPY",
+    REPLACE: "REPLACE"
+  };
+  ObjectLockLegalHoldStatus = {
+    OFF: "OFF",
+    ON: "ON"
+  };
+  ObjectLockMode = {
+    COMPLIANCE: "COMPLIANCE",
+    GOVERNANCE: "GOVERNANCE"
+  };
+  StorageClass = {
+    DEEP_ARCHIVE: "DEEP_ARCHIVE",
+    EXPRESS_ONEZONE: "EXPRESS_ONEZONE",
+    FSX_ONTAP: "FSX_ONTAP",
+    FSX_OPENZFS: "FSX_OPENZFS",
+    GLACIER: "GLACIER",
+    GLACIER_IR: "GLACIER_IR",
+    INTELLIGENT_TIERING: "INTELLIGENT_TIERING",
+    ONEZONE_IA: "ONEZONE_IA",
+    OUTPOSTS: "OUTPOSTS",
+    REDUCED_REDUNDANCY: "REDUCED_REDUNDANCY",
+    SNOW: "SNOW",
+    STANDARD: "STANDARD",
+    STANDARD_IA: "STANDARD_IA"
+  };
+  TaggingDirective = {
+    COPY: "COPY",
+    REPLACE: "REPLACE"
+  };
+  BucketCannedACL = {
+    authenticated_read: "authenticated-read",
+    private: "private",
+    public_read: "public-read",
+    public_read_write: "public-read-write"
+  };
+  BucketNamespace = {
+    ACCOUNT_REGIONAL: "account-regional",
+    GLOBAL: "global"
+  };
+  DataRedundancy = {
+    SingleAvailabilityZone: "SingleAvailabilityZone",
+    SingleLocalZone: "SingleLocalZone"
+  };
+  BucketType = {
+    Directory: "Directory"
+  };
+  LocationType = {
+    AvailabilityZone: "AvailabilityZone",
+    LocalZone: "LocalZone"
+  };
+  BucketLocationConstraint = {
+    EU: "EU",
+    af_south_1: "af-south-1",
+    ap_east_1: "ap-east-1",
+    ap_northeast_1: "ap-northeast-1",
+    ap_northeast_2: "ap-northeast-2",
+    ap_northeast_3: "ap-northeast-3",
+    ap_south_1: "ap-south-1",
+    ap_south_2: "ap-south-2",
+    ap_southeast_1: "ap-southeast-1",
+    ap_southeast_2: "ap-southeast-2",
+    ap_southeast_3: "ap-southeast-3",
+    ap_southeast_4: "ap-southeast-4",
+    ap_southeast_5: "ap-southeast-5",
+    ca_central_1: "ca-central-1",
+    cn_north_1: "cn-north-1",
+    cn_northwest_1: "cn-northwest-1",
+    eu_central_1: "eu-central-1",
+    eu_central_2: "eu-central-2",
+    eu_north_1: "eu-north-1",
+    eu_south_1: "eu-south-1",
+    eu_south_2: "eu-south-2",
+    eu_west_1: "eu-west-1",
+    eu_west_2: "eu-west-2",
+    eu_west_3: "eu-west-3",
+    il_central_1: "il-central-1",
+    me_central_1: "me-central-1",
+    me_south_1: "me-south-1",
+    sa_east_1: "sa-east-1",
+    us_east_2: "us-east-2",
+    us_gov_east_1: "us-gov-east-1",
+    us_gov_west_1: "us-gov-west-1",
+    us_west_1: "us-west-1",
+    us_west_2: "us-west-2"
+  };
+  ObjectOwnership = {
+    BucketOwnerEnforced: "BucketOwnerEnforced",
+    BucketOwnerPreferred: "BucketOwnerPreferred",
+    ObjectWriter: "ObjectWriter"
+  };
+  InventoryConfigurationState = {
+    DISABLED: "DISABLED",
+    ENABLED: "ENABLED"
+  };
+  TableSseAlgorithm = {
+    AES256: "AES256",
+    aws_kms: "aws:kms"
+  };
+  ExpirationState = {
+    DISABLED: "DISABLED",
+    ENABLED: "ENABLED"
+  };
+  SessionMode = {
+    ReadOnly: "ReadOnly",
+    ReadWrite: "ReadWrite"
+  };
+  AnalyticsS3ExportFileFormat = {
+    CSV: "CSV"
+  };
+  StorageClassAnalysisSchemaVersion = {
+    V_1: "V_1"
+  };
+  EncryptionType = {
+    NONE: "NONE",
+    SSE_C: "SSE-C"
+  };
+  IntelligentTieringStatus = {
+    Disabled: "Disabled",
+    Enabled: "Enabled"
+  };
+  IntelligentTieringAccessTier = {
+    ARCHIVE_ACCESS: "ARCHIVE_ACCESS",
+    DEEP_ARCHIVE_ACCESS: "DEEP_ARCHIVE_ACCESS"
+  };
+  InventoryFormat = {
+    CSV: "CSV",
+    ORC: "ORC",
+    Parquet: "Parquet"
+  };
+  InventoryIncludedObjectVersions = {
+    All: "All",
+    Current: "Current"
+  };
+  InventoryOptionalField = {
+    BucketKeyStatus: "BucketKeyStatus",
+    ChecksumAlgorithm: "ChecksumAlgorithm",
+    ETag: "ETag",
+    EncryptionStatus: "EncryptionStatus",
+    IntelligentTieringAccessTier: "IntelligentTieringAccessTier",
+    IsMultipartUploaded: "IsMultipartUploaded",
+    LastModifiedDate: "LastModifiedDate",
+    LifecycleExpirationDate: "LifecycleExpirationDate",
+    ObjectAccessControlList: "ObjectAccessControlList",
+    ObjectLockLegalHoldStatus: "ObjectLockLegalHoldStatus",
+    ObjectLockMode: "ObjectLockMode",
+    ObjectLockRetainUntilDate: "ObjectLockRetainUntilDate",
+    ObjectOwner: "ObjectOwner",
+    ReplicationStatus: "ReplicationStatus",
+    Size: "Size",
+    StorageClass: "StorageClass"
+  };
+  InventoryFrequency = {
+    Daily: "Daily",
+    Weekly: "Weekly"
+  };
+  TransitionStorageClass = {
+    DEEP_ARCHIVE: "DEEP_ARCHIVE",
+    GLACIER: "GLACIER",
+    GLACIER_IR: "GLACIER_IR",
+    INTELLIGENT_TIERING: "INTELLIGENT_TIERING",
+    ONEZONE_IA: "ONEZONE_IA",
+    STANDARD_IA: "STANDARD_IA"
+  };
+  ExpirationStatus = {
+    Disabled: "Disabled",
+    Enabled: "Enabled"
+  };
+  TransitionDefaultMinimumObjectSize = {
+    all_storage_classes_128K: "all_storage_classes_128K",
+    varies_by_storage_class: "varies_by_storage_class"
+  };
+  BucketLogsPermission = {
+    FULL_CONTROL: "FULL_CONTROL",
+    READ: "READ",
+    WRITE: "WRITE"
+  };
+  PartitionDateSource = {
+    DeliveryTime: "DeliveryTime",
+    EventTime: "EventTime"
+  };
+  S3TablesBucketType = {
+    aws: "aws",
+    customer: "customer"
+  };
+  Event = {
+    s3_IntelligentTiering: "s3:IntelligentTiering",
+    s3_LifecycleExpiration_: "s3:LifecycleExpiration:*",
+    s3_LifecycleExpiration_Delete: "s3:LifecycleExpiration:Delete",
+    s3_LifecycleExpiration_DeleteMarkerCreated: "s3:LifecycleExpiration:DeleteMarkerCreated",
+    s3_LifecycleTransition: "s3:LifecycleTransition",
+    s3_ObjectAcl_Put: "s3:ObjectAcl:Put",
+    s3_ObjectCreated_: "s3:ObjectCreated:*",
+    s3_ObjectCreated_CompleteMultipartUpload: "s3:ObjectCreated:CompleteMultipartUpload",
+    s3_ObjectCreated_Copy: "s3:ObjectCreated:Copy",
+    s3_ObjectCreated_Post: "s3:ObjectCreated:Post",
+    s3_ObjectCreated_Put: "s3:ObjectCreated:Put",
+    s3_ObjectRemoved_: "s3:ObjectRemoved:*",
+    s3_ObjectRemoved_Delete: "s3:ObjectRemoved:Delete",
+    s3_ObjectRemoved_DeleteMarkerCreated: "s3:ObjectRemoved:DeleteMarkerCreated",
+    s3_ObjectRestore_: "s3:ObjectRestore:*",
+    s3_ObjectRestore_Completed: "s3:ObjectRestore:Completed",
+    s3_ObjectRestore_Delete: "s3:ObjectRestore:Delete",
+    s3_ObjectRestore_Post: "s3:ObjectRestore:Post",
+    s3_ObjectTagging_: "s3:ObjectTagging:*",
+    s3_ObjectTagging_Delete: "s3:ObjectTagging:Delete",
+    s3_ObjectTagging_Put: "s3:ObjectTagging:Put",
+    s3_ReducedRedundancyLostObject: "s3:ReducedRedundancyLostObject",
+    s3_Replication_: "s3:Replication:*",
+    s3_Replication_OperationFailedReplication: "s3:Replication:OperationFailedReplication",
+    s3_Replication_OperationMissedThreshold: "s3:Replication:OperationMissedThreshold",
+    s3_Replication_OperationNotTracked: "s3:Replication:OperationNotTracked",
+    s3_Replication_OperationReplicatedAfterThreshold: "s3:Replication:OperationReplicatedAfterThreshold"
+  };
+  FilterRuleName = {
+    prefix: "prefix",
+    suffix: "suffix"
+  };
+  DeleteMarkerReplicationStatus = {
+    Disabled: "Disabled",
+    Enabled: "Enabled"
+  };
+  MetricsStatus = {
+    Disabled: "Disabled",
+    Enabled: "Enabled"
+  };
+  ReplicationTimeStatus = {
+    Disabled: "Disabled",
+    Enabled: "Enabled"
+  };
+  ExistingObjectReplicationStatus = {
+    Disabled: "Disabled",
+    Enabled: "Enabled"
+  };
+  ReplicaModificationsStatus = {
+    Disabled: "Disabled",
+    Enabled: "Enabled"
+  };
+  SseKmsEncryptedObjectsStatus = {
+    Disabled: "Disabled",
+    Enabled: "Enabled"
+  };
+  ReplicationRuleStatus = {
+    Disabled: "Disabled",
+    Enabled: "Enabled"
+  };
+  Payer = {
+    BucketOwner: "BucketOwner",
+    Requester: "Requester"
+  };
+  MFADeleteStatus = {
+    Disabled: "Disabled",
+    Enabled: "Enabled"
+  };
+  BucketVersioningStatus = {
+    Enabled: "Enabled",
+    Suspended: "Suspended"
+  };
+  Protocol = {
+    http: "http",
+    https: "https"
+  };
+  ReplicationStatus = {
+    COMPLETE: "COMPLETE",
+    COMPLETED: "COMPLETED",
+    FAILED: "FAILED",
+    PENDING: "PENDING",
+    REPLICA: "REPLICA"
+  };
+  ChecksumMode = {
+    ENABLED: "ENABLED"
+  };
+  ObjectAttributes = {
+    CHECKSUM: "Checksum",
+    ETAG: "ETag",
+    OBJECT_PARTS: "ObjectParts",
+    OBJECT_SIZE: "ObjectSize",
+    STORAGE_CLASS: "StorageClass"
+  };
+  ObjectLockEnabled = {
+    Enabled: "Enabled"
+  };
+  ObjectLockRetentionMode = {
+    COMPLIANCE: "COMPLIANCE",
+    GOVERNANCE: "GOVERNANCE"
+  };
+  ArchiveStatus = {
+    ARCHIVE_ACCESS: "ARCHIVE_ACCESS",
+    DEEP_ARCHIVE_ACCESS: "DEEP_ARCHIVE_ACCESS"
+  };
+  EncodingType = {
+    url: "url"
+  };
+  ObjectStorageClass = {
+    DEEP_ARCHIVE: "DEEP_ARCHIVE",
+    EXPRESS_ONEZONE: "EXPRESS_ONEZONE",
+    FSX_ONTAP: "FSX_ONTAP",
+    FSX_OPENZFS: "FSX_OPENZFS",
+    GLACIER: "GLACIER",
+    GLACIER_IR: "GLACIER_IR",
+    INTELLIGENT_TIERING: "INTELLIGENT_TIERING",
+    ONEZONE_IA: "ONEZONE_IA",
+    OUTPOSTS: "OUTPOSTS",
+    REDUCED_REDUNDANCY: "REDUCED_REDUNDANCY",
+    SNOW: "SNOW",
+    STANDARD: "STANDARD",
+    STANDARD_IA: "STANDARD_IA"
+  };
+  OptionalObjectAttributes = {
+    RESTORE_STATUS: "RestoreStatus"
+  };
+  ObjectVersionStorageClass = {
+    STANDARD: "STANDARD"
+  };
+  MFADelete = {
+    Disabled: "Disabled",
+    Enabled: "Enabled"
+  };
+  Tier = {
+    Bulk: "Bulk",
+    Expedited: "Expedited",
+    Standard: "Standard"
+  };
+  ExpressionType = {
+    SQL: "SQL"
+  };
+  CompressionType = {
+    BZIP2: "BZIP2",
+    GZIP: "GZIP",
+    NONE: "NONE"
+  };
+  FileHeaderInfo = {
+    IGNORE: "IGNORE",
+    NONE: "NONE",
+    USE: "USE"
+  };
+  JSONType = {
+    DOCUMENT: "DOCUMENT",
+    LINES: "LINES"
+  };
+  QuoteFields = {
+    ALWAYS: "ALWAYS",
+    ASNEEDED: "ASNEEDED"
+  };
+  RestoreRequestType = {
+    SELECT: "SELECT"
+  };
 });
 
 // node_modules/@aws-sdk/client-s3/dist-es/models/models_0.js
@@ -43385,7 +44255,679 @@ var init_models_0 = () => {};
 var init_models_1 = () => {};
 
 // node_modules/@aws-sdk/client-s3/dist-es/index.js
+var exports_dist_es8 = {};
+__export(exports_dist_es8, {
+  waitUntilObjectNotExists: () => waitUntilObjectNotExists,
+  waitUntilObjectExists: () => waitUntilObjectExists,
+  waitUntilBucketNotExists: () => waitUntilBucketNotExists,
+  waitUntilBucketExists: () => waitUntilBucketExists,
+  waitForObjectNotExists: () => waitForObjectNotExists,
+  waitForObjectExists: () => waitForObjectExists,
+  waitForBucketNotExists: () => waitForBucketNotExists,
+  waitForBucketExists: () => waitForBucketExists,
+  paginateListParts: () => paginateListParts,
+  paginateListObjectsV2: () => paginateListObjectsV2,
+  paginateListDirectoryBuckets: () => paginateListDirectoryBuckets,
+  paginateListBuckets: () => paginateListBuckets,
+  errorTypeRegistries: () => errorTypeRegistries,
+  __Client: () => import_smithy_client9.Client,
+  _Object$: () => _Object$,
+  _Error$: () => _Error$,
+  WriteGetObjectResponseRequest$: () => WriteGetObjectResponseRequest$,
+  WriteGetObjectResponseCommand: () => WriteGetObjectResponseCommand,
+  WriteGetObjectResponse$: () => WriteGetObjectResponse$,
+  WebsiteConfiguration$: () => WebsiteConfiguration$,
+  VersioningConfiguration$: () => VersioningConfiguration$,
+  UploadPartRequest$: () => UploadPartRequest$,
+  UploadPartOutput$: () => UploadPartOutput$,
+  UploadPartCopyRequest$: () => UploadPartCopyRequest$,
+  UploadPartCopyOutput$: () => UploadPartCopyOutput$,
+  UploadPartCopyCommand: () => UploadPartCopyCommand,
+  UploadPartCopy$: () => UploadPartCopy$,
+  UploadPartCommand: () => UploadPartCommand,
+  UploadPart$: () => UploadPart$,
+  UpdateObjectEncryptionResponse$: () => UpdateObjectEncryptionResponse$,
+  UpdateObjectEncryptionRequest$: () => UpdateObjectEncryptionRequest$,
+  UpdateObjectEncryptionCommand: () => UpdateObjectEncryptionCommand,
+  UpdateObjectEncryption$: () => UpdateObjectEncryption$,
+  UpdateBucketMetadataJournalTableConfigurationRequest$: () => UpdateBucketMetadataJournalTableConfigurationRequest$,
+  UpdateBucketMetadataJournalTableConfigurationCommand: () => UpdateBucketMetadataJournalTableConfigurationCommand,
+  UpdateBucketMetadataJournalTableConfiguration$: () => UpdateBucketMetadataJournalTableConfiguration$,
+  UpdateBucketMetadataInventoryTableConfigurationRequest$: () => UpdateBucketMetadataInventoryTableConfigurationRequest$,
+  UpdateBucketMetadataInventoryTableConfigurationCommand: () => UpdateBucketMetadataInventoryTableConfigurationCommand,
+  UpdateBucketMetadataInventoryTableConfiguration$: () => UpdateBucketMetadataInventoryTableConfiguration$,
+  Type: () => Type,
+  TransitionStorageClass: () => TransitionStorageClass,
+  TransitionDefaultMinimumObjectSize: () => TransitionDefaultMinimumObjectSize,
+  Transition$: () => Transition$,
+  TopicConfiguration$: () => TopicConfiguration$,
+  TooManyParts$: () => TooManyParts$,
+  TooManyParts: () => TooManyParts,
+  Tiering$: () => Tiering$,
+  Tier: () => Tier,
+  TargetObjectKeyFormat$: () => TargetObjectKeyFormat$,
+  TargetGrant$: () => TargetGrant$,
+  TaggingDirective: () => TaggingDirective,
+  Tagging$: () => Tagging$,
+  Tag$: () => Tag$,
+  TableSseAlgorithm: () => TableSseAlgorithm,
+  StorageClassAnalysisSchemaVersion: () => StorageClassAnalysisSchemaVersion,
+  StorageClassAnalysisDataExport$: () => StorageClassAnalysisDataExport$,
+  StorageClassAnalysis$: () => StorageClassAnalysis$,
+  StorageClass: () => StorageClass,
+  StatsEvent$: () => StatsEvent$,
+  Stats$: () => Stats$,
+  SseKmsEncryptedObjectsStatus: () => SseKmsEncryptedObjectsStatus,
+  SseKmsEncryptedObjects$: () => SseKmsEncryptedObjects$,
+  SourceSelectionCriteria$: () => SourceSelectionCriteria$,
+  SimplePrefix$: () => SimplePrefix$,
+  SessionMode: () => SessionMode,
+  SessionCredentials$: () => SessionCredentials$,
+  ServerSideEncryptionRule$: () => ServerSideEncryptionRule$,
+  ServerSideEncryptionConfiguration$: () => ServerSideEncryptionConfiguration$,
+  ServerSideEncryptionByDefault$: () => ServerSideEncryptionByDefault$,
+  ServerSideEncryption: () => ServerSideEncryption,
+  SelectParameters$: () => SelectParameters$,
+  SelectObjectContentRequest$: () => SelectObjectContentRequest$,
+  SelectObjectContentOutput$: () => SelectObjectContentOutput$,
+  SelectObjectContentEventStream$: () => SelectObjectContentEventStream$,
+  SelectObjectContentCommand: () => SelectObjectContentCommand,
+  SelectObjectContent$: () => SelectObjectContent$,
+  ScanRange$: () => ScanRange$,
+  SSES3$: () => SSES3$,
+  SSEKMSEncryption$: () => SSEKMSEncryption$,
+  SSEKMS$: () => SSEKMS$,
+  S3TablesDestinationResult$: () => S3TablesDestinationResult$,
+  S3TablesDestination$: () => S3TablesDestination$,
+  S3TablesBucketType: () => S3TablesBucketType,
+  S3ServiceException$: () => S3ServiceException$,
+  S3ServiceException: () => S3ServiceException,
+  S3Location$: () => S3Location$,
+  S3KeyFilter$: () => S3KeyFilter$,
+  S3Client: () => S3Client,
+  S3: () => S3,
+  RoutingRule$: () => RoutingRule$,
+  RestoreStatus$: () => RestoreStatus$,
+  RestoreRequestType: () => RestoreRequestType,
+  RestoreRequest$: () => RestoreRequest$,
+  RestoreObjectRequest$: () => RestoreObjectRequest$,
+  RestoreObjectOutput$: () => RestoreObjectOutput$,
+  RestoreObjectCommand: () => RestoreObjectCommand,
+  RestoreObject$: () => RestoreObject$,
+  RequestProgress$: () => RequestProgress$,
+  RequestPaymentConfiguration$: () => RequestPaymentConfiguration$,
+  RequestPayer: () => RequestPayer,
+  RequestCharged: () => RequestCharged,
+  ReplicationTimeValue$: () => ReplicationTimeValue$,
+  ReplicationTimeStatus: () => ReplicationTimeStatus,
+  ReplicationTime$: () => ReplicationTime$,
+  ReplicationStatus: () => ReplicationStatus,
+  ReplicationRuleStatus: () => ReplicationRuleStatus,
+  ReplicationRuleFilter$: () => ReplicationRuleFilter$,
+  ReplicationRuleAndOperator$: () => ReplicationRuleAndOperator$,
+  ReplicationRule$: () => ReplicationRule$,
+  ReplicationConfiguration$: () => ReplicationConfiguration$,
+  ReplicaModificationsStatus: () => ReplicaModificationsStatus,
+  ReplicaModifications$: () => ReplicaModifications$,
+  RenameObjectRequest$: () => RenameObjectRequest$,
+  RenameObjectOutput$: () => RenameObjectOutput$,
+  RenameObjectCommand: () => RenameObjectCommand,
+  RenameObject$: () => RenameObject$,
+  RedirectAllRequestsTo$: () => RedirectAllRequestsTo$,
+  Redirect$: () => Redirect$,
+  RecordsEvent$: () => RecordsEvent$,
+  RecordExpiration$: () => RecordExpiration$,
+  QuoteFields: () => QuoteFields,
+  QueueConfiguration$: () => QueueConfiguration$,
+  PutPublicAccessBlockRequest$: () => PutPublicAccessBlockRequest$,
+  PutPublicAccessBlockCommand: () => PutPublicAccessBlockCommand,
+  PutPublicAccessBlock$: () => PutPublicAccessBlock$,
+  PutObjectTaggingRequest$: () => PutObjectTaggingRequest$,
+  PutObjectTaggingOutput$: () => PutObjectTaggingOutput$,
+  PutObjectTaggingCommand: () => PutObjectTaggingCommand,
+  PutObjectTagging$: () => PutObjectTagging$,
+  PutObjectRetentionRequest$: () => PutObjectRetentionRequest$,
+  PutObjectRetentionOutput$: () => PutObjectRetentionOutput$,
+  PutObjectRetentionCommand: () => PutObjectRetentionCommand,
+  PutObjectRetention$: () => PutObjectRetention$,
+  PutObjectRequest$: () => PutObjectRequest$,
+  PutObjectOutput$: () => PutObjectOutput$,
+  PutObjectLockConfigurationRequest$: () => PutObjectLockConfigurationRequest$,
+  PutObjectLockConfigurationOutput$: () => PutObjectLockConfigurationOutput$,
+  PutObjectLockConfigurationCommand: () => PutObjectLockConfigurationCommand,
+  PutObjectLockConfiguration$: () => PutObjectLockConfiguration$,
+  PutObjectLegalHoldRequest$: () => PutObjectLegalHoldRequest$,
+  PutObjectLegalHoldOutput$: () => PutObjectLegalHoldOutput$,
+  PutObjectLegalHoldCommand: () => PutObjectLegalHoldCommand,
+  PutObjectLegalHold$: () => PutObjectLegalHold$,
+  PutObjectCommand: () => PutObjectCommand,
+  PutObjectAclRequest$: () => PutObjectAclRequest$,
+  PutObjectAclOutput$: () => PutObjectAclOutput$,
+  PutObjectAclCommand: () => PutObjectAclCommand,
+  PutObjectAcl$: () => PutObjectAcl$,
+  PutObject$: () => PutObject$,
+  PutBucketWebsiteRequest$: () => PutBucketWebsiteRequest$,
+  PutBucketWebsiteCommand: () => PutBucketWebsiteCommand,
+  PutBucketWebsite$: () => PutBucketWebsite$,
+  PutBucketVersioningRequest$: () => PutBucketVersioningRequest$,
+  PutBucketVersioningCommand: () => PutBucketVersioningCommand,
+  PutBucketVersioning$: () => PutBucketVersioning$,
+  PutBucketTaggingRequest$: () => PutBucketTaggingRequest$,
+  PutBucketTaggingCommand: () => PutBucketTaggingCommand,
+  PutBucketTagging$: () => PutBucketTagging$,
+  PutBucketRequestPaymentRequest$: () => PutBucketRequestPaymentRequest$,
+  PutBucketRequestPaymentCommand: () => PutBucketRequestPaymentCommand,
+  PutBucketRequestPayment$: () => PutBucketRequestPayment$,
+  PutBucketReplicationRequest$: () => PutBucketReplicationRequest$,
+  PutBucketReplicationCommand: () => PutBucketReplicationCommand,
+  PutBucketReplication$: () => PutBucketReplication$,
+  PutBucketPolicyRequest$: () => PutBucketPolicyRequest$,
+  PutBucketPolicyCommand: () => PutBucketPolicyCommand,
+  PutBucketPolicy$: () => PutBucketPolicy$,
+  PutBucketOwnershipControlsRequest$: () => PutBucketOwnershipControlsRequest$,
+  PutBucketOwnershipControlsCommand: () => PutBucketOwnershipControlsCommand,
+  PutBucketOwnershipControls$: () => PutBucketOwnershipControls$,
+  PutBucketNotificationConfigurationRequest$: () => PutBucketNotificationConfigurationRequest$,
+  PutBucketNotificationConfigurationCommand: () => PutBucketNotificationConfigurationCommand,
+  PutBucketNotificationConfiguration$: () => PutBucketNotificationConfiguration$,
+  PutBucketMetricsConfigurationRequest$: () => PutBucketMetricsConfigurationRequest$,
+  PutBucketMetricsConfigurationCommand: () => PutBucketMetricsConfigurationCommand,
+  PutBucketMetricsConfiguration$: () => PutBucketMetricsConfiguration$,
+  PutBucketLoggingRequest$: () => PutBucketLoggingRequest$,
+  PutBucketLoggingCommand: () => PutBucketLoggingCommand,
+  PutBucketLogging$: () => PutBucketLogging$,
+  PutBucketLifecycleConfigurationRequest$: () => PutBucketLifecycleConfigurationRequest$,
+  PutBucketLifecycleConfigurationOutput$: () => PutBucketLifecycleConfigurationOutput$,
+  PutBucketLifecycleConfigurationCommand: () => PutBucketLifecycleConfigurationCommand,
+  PutBucketLifecycleConfiguration$: () => PutBucketLifecycleConfiguration$,
+  PutBucketInventoryConfigurationRequest$: () => PutBucketInventoryConfigurationRequest$,
+  PutBucketInventoryConfigurationCommand: () => PutBucketInventoryConfigurationCommand,
+  PutBucketInventoryConfiguration$: () => PutBucketInventoryConfiguration$,
+  PutBucketIntelligentTieringConfigurationRequest$: () => PutBucketIntelligentTieringConfigurationRequest$,
+  PutBucketIntelligentTieringConfigurationCommand: () => PutBucketIntelligentTieringConfigurationCommand,
+  PutBucketIntelligentTieringConfiguration$: () => PutBucketIntelligentTieringConfiguration$,
+  PutBucketEncryptionRequest$: () => PutBucketEncryptionRequest$,
+  PutBucketEncryptionCommand: () => PutBucketEncryptionCommand,
+  PutBucketEncryption$: () => PutBucketEncryption$,
+  PutBucketCorsRequest$: () => PutBucketCorsRequest$,
+  PutBucketCorsCommand: () => PutBucketCorsCommand,
+  PutBucketCors$: () => PutBucketCors$,
+  PutBucketAnalyticsConfigurationRequest$: () => PutBucketAnalyticsConfigurationRequest$,
+  PutBucketAnalyticsConfigurationCommand: () => PutBucketAnalyticsConfigurationCommand,
+  PutBucketAnalyticsConfiguration$: () => PutBucketAnalyticsConfiguration$,
+  PutBucketAclRequest$: () => PutBucketAclRequest$,
+  PutBucketAclCommand: () => PutBucketAclCommand,
+  PutBucketAcl$: () => PutBucketAcl$,
+  PutBucketAccelerateConfigurationRequest$: () => PutBucketAccelerateConfigurationRequest$,
+  PutBucketAccelerateConfigurationCommand: () => PutBucketAccelerateConfigurationCommand,
+  PutBucketAccelerateConfiguration$: () => PutBucketAccelerateConfiguration$,
+  PutBucketAbacRequest$: () => PutBucketAbacRequest$,
+  PutBucketAbacCommand: () => PutBucketAbacCommand,
+  PutBucketAbac$: () => PutBucketAbac$,
+  PublicAccessBlockConfiguration$: () => PublicAccessBlockConfiguration$,
+  Protocol: () => Protocol,
+  ProgressEvent$: () => ProgressEvent$,
+  Progress$: () => Progress$,
+  PolicyStatus$: () => PolicyStatus$,
+  Permission: () => Permission,
+  Payer: () => Payer,
+  PartitionedPrefix$: () => PartitionedPrefix$,
+  PartitionDateSource: () => PartitionDateSource,
+  Part$: () => Part$,
+  ParquetInput$: () => ParquetInput$,
+  OwnershipControlsRule$: () => OwnershipControlsRule$,
+  OwnershipControls$: () => OwnershipControls$,
+  OwnerOverride: () => OwnerOverride,
+  Owner$: () => Owner$,
+  OutputSerialization$: () => OutputSerialization$,
+  OutputLocation$: () => OutputLocation$,
+  OptionalObjectAttributes: () => OptionalObjectAttributes,
+  ObjectVersionStorageClass: () => ObjectVersionStorageClass,
+  ObjectVersion$: () => ObjectVersion$,
+  ObjectStorageClass: () => ObjectStorageClass,
+  ObjectPart$: () => ObjectPart$,
+  ObjectOwnership: () => ObjectOwnership,
+  ObjectNotInActiveTierError$: () => ObjectNotInActiveTierError$,
+  ObjectNotInActiveTierError: () => ObjectNotInActiveTierError,
+  ObjectLockRule$: () => ObjectLockRule$,
+  ObjectLockRetentionMode: () => ObjectLockRetentionMode,
+  ObjectLockRetention$: () => ObjectLockRetention$,
+  ObjectLockMode: () => ObjectLockMode,
+  ObjectLockLegalHoldStatus: () => ObjectLockLegalHoldStatus,
+  ObjectLockLegalHold$: () => ObjectLockLegalHold$,
+  ObjectLockEnabled: () => ObjectLockEnabled,
+  ObjectLockConfiguration$: () => ObjectLockConfiguration$,
+  ObjectIdentifier$: () => ObjectIdentifier$,
+  ObjectEncryption$: () => ObjectEncryption$,
+  ObjectCannedACL: () => ObjectCannedACL,
+  ObjectAttributes: () => ObjectAttributes,
+  ObjectAlreadyInActiveTierError$: () => ObjectAlreadyInActiveTierError$,
+  ObjectAlreadyInActiveTierError: () => ObjectAlreadyInActiveTierError,
+  NotificationConfigurationFilter$: () => NotificationConfigurationFilter$,
+  NotificationConfiguration$: () => NotificationConfiguration$,
+  NotFound$: () => NotFound$,
+  NotFound: () => NotFound,
+  NoncurrentVersionTransition$: () => NoncurrentVersionTransition$,
+  NoncurrentVersionExpiration$: () => NoncurrentVersionExpiration$,
+  NoSuchUpload$: () => NoSuchUpload$,
+  NoSuchUpload: () => NoSuchUpload,
+  NoSuchKey$: () => NoSuchKey$,
+  NoSuchKey: () => NoSuchKey,
+  NoSuchBucket$: () => NoSuchBucket$,
+  NoSuchBucket: () => NoSuchBucket,
+  MultipartUpload$: () => MultipartUpload$,
+  MetricsStatus: () => MetricsStatus,
+  MetricsFilter$: () => MetricsFilter$,
+  MetricsConfiguration$: () => MetricsConfiguration$,
+  MetricsAndOperator$: () => MetricsAndOperator$,
+  Metrics$: () => Metrics$,
+  MetadataTableEncryptionConfiguration$: () => MetadataTableEncryptionConfiguration$,
+  MetadataTableConfigurationResult$: () => MetadataTableConfigurationResult$,
+  MetadataTableConfiguration$: () => MetadataTableConfiguration$,
+  MetadataEntry$: () => MetadataEntry$,
+  MetadataDirective: () => MetadataDirective,
+  MetadataConfigurationResult$: () => MetadataConfigurationResult$,
+  MetadataConfiguration$: () => MetadataConfiguration$,
+  MFADeleteStatus: () => MFADeleteStatus,
+  MFADelete: () => MFADelete,
+  LoggingEnabled$: () => LoggingEnabled$,
+  LocationType: () => LocationType,
+  LocationInfo$: () => LocationInfo$,
+  ListPartsRequest$: () => ListPartsRequest$,
+  ListPartsOutput$: () => ListPartsOutput$,
+  ListPartsCommand: () => ListPartsCommand,
+  ListParts$: () => ListParts$,
+  ListObjectsV2Request$: () => ListObjectsV2Request$,
+  ListObjectsV2Output$: () => ListObjectsV2Output$,
+  ListObjectsV2Command: () => ListObjectsV2Command,
+  ListObjectsV2$: () => ListObjectsV2$,
+  ListObjectsRequest$: () => ListObjectsRequest$,
+  ListObjectsOutput$: () => ListObjectsOutput$,
+  ListObjectsCommand: () => ListObjectsCommand,
+  ListObjects$: () => ListObjects$,
+  ListObjectVersionsRequest$: () => ListObjectVersionsRequest$,
+  ListObjectVersionsOutput$: () => ListObjectVersionsOutput$,
+  ListObjectVersionsCommand: () => ListObjectVersionsCommand,
+  ListObjectVersions$: () => ListObjectVersions$,
+  ListMultipartUploadsRequest$: () => ListMultipartUploadsRequest$,
+  ListMultipartUploadsOutput$: () => ListMultipartUploadsOutput$,
+  ListMultipartUploadsCommand: () => ListMultipartUploadsCommand,
+  ListMultipartUploads$: () => ListMultipartUploads$,
+  ListDirectoryBucketsRequest$: () => ListDirectoryBucketsRequest$,
+  ListDirectoryBucketsOutput$: () => ListDirectoryBucketsOutput$,
+  ListDirectoryBucketsCommand: () => ListDirectoryBucketsCommand,
+  ListDirectoryBuckets$: () => ListDirectoryBuckets$,
+  ListBucketsRequest$: () => ListBucketsRequest$,
+  ListBucketsOutput$: () => ListBucketsOutput$,
+  ListBucketsCommand: () => ListBucketsCommand,
+  ListBuckets$: () => ListBuckets$,
+  ListBucketMetricsConfigurationsRequest$: () => ListBucketMetricsConfigurationsRequest$,
+  ListBucketMetricsConfigurationsOutput$: () => ListBucketMetricsConfigurationsOutput$,
+  ListBucketMetricsConfigurationsCommand: () => ListBucketMetricsConfigurationsCommand,
+  ListBucketMetricsConfigurations$: () => ListBucketMetricsConfigurations$,
+  ListBucketInventoryConfigurationsRequest$: () => ListBucketInventoryConfigurationsRequest$,
+  ListBucketInventoryConfigurationsOutput$: () => ListBucketInventoryConfigurationsOutput$,
+  ListBucketInventoryConfigurationsCommand: () => ListBucketInventoryConfigurationsCommand,
+  ListBucketInventoryConfigurations$: () => ListBucketInventoryConfigurations$,
+  ListBucketIntelligentTieringConfigurationsRequest$: () => ListBucketIntelligentTieringConfigurationsRequest$,
+  ListBucketIntelligentTieringConfigurationsOutput$: () => ListBucketIntelligentTieringConfigurationsOutput$,
+  ListBucketIntelligentTieringConfigurationsCommand: () => ListBucketIntelligentTieringConfigurationsCommand,
+  ListBucketIntelligentTieringConfigurations$: () => ListBucketIntelligentTieringConfigurations$,
+  ListBucketAnalyticsConfigurationsRequest$: () => ListBucketAnalyticsConfigurationsRequest$,
+  ListBucketAnalyticsConfigurationsOutput$: () => ListBucketAnalyticsConfigurationsOutput$,
+  ListBucketAnalyticsConfigurationsCommand: () => ListBucketAnalyticsConfigurationsCommand,
+  ListBucketAnalyticsConfigurations$: () => ListBucketAnalyticsConfigurations$,
+  LifecycleRuleFilter$: () => LifecycleRuleFilter$,
+  LifecycleRuleAndOperator$: () => LifecycleRuleAndOperator$,
+  LifecycleRule$: () => LifecycleRule$,
+  LifecycleExpiration$: () => LifecycleExpiration$,
+  LambdaFunctionConfiguration$: () => LambdaFunctionConfiguration$,
+  JournalTableConfigurationUpdates$: () => JournalTableConfigurationUpdates$,
+  JournalTableConfigurationResult$: () => JournalTableConfigurationResult$,
+  JournalTableConfiguration$: () => JournalTableConfiguration$,
+  JSONType: () => JSONType,
+  JSONOutput$: () => JSONOutput$,
+  JSONInput$: () => JSONInput$,
+  InventoryTableConfigurationUpdates$: () => InventoryTableConfigurationUpdates$,
+  InventoryTableConfigurationResult$: () => InventoryTableConfigurationResult$,
+  InventoryTableConfiguration$: () => InventoryTableConfiguration$,
+  InventorySchedule$: () => InventorySchedule$,
+  InventoryS3BucketDestination$: () => InventoryS3BucketDestination$,
+  InventoryOptionalField: () => InventoryOptionalField,
+  InventoryIncludedObjectVersions: () => InventoryIncludedObjectVersions,
+  InventoryFrequency: () => InventoryFrequency,
+  InventoryFormat: () => InventoryFormat,
+  InventoryFilter$: () => InventoryFilter$,
+  InventoryEncryption$: () => InventoryEncryption$,
+  InventoryDestination$: () => InventoryDestination$,
+  InventoryConfigurationState: () => InventoryConfigurationState,
+  InventoryConfiguration$: () => InventoryConfiguration$,
+  InvalidWriteOffset$: () => InvalidWriteOffset$,
+  InvalidWriteOffset: () => InvalidWriteOffset,
+  InvalidRequest$: () => InvalidRequest$,
+  InvalidRequest: () => InvalidRequest,
+  InvalidObjectState$: () => InvalidObjectState$,
+  InvalidObjectState: () => InvalidObjectState,
+  IntelligentTieringStatus: () => IntelligentTieringStatus,
+  IntelligentTieringFilter$: () => IntelligentTieringFilter$,
+  IntelligentTieringConfiguration$: () => IntelligentTieringConfiguration$,
+  IntelligentTieringAndOperator$: () => IntelligentTieringAndOperator$,
+  IntelligentTieringAccessTier: () => IntelligentTieringAccessTier,
+  InputSerialization$: () => InputSerialization$,
+  Initiator$: () => Initiator$,
+  IndexDocument$: () => IndexDocument$,
+  IdempotencyParameterMismatch$: () => IdempotencyParameterMismatch$,
+  IdempotencyParameterMismatch: () => IdempotencyParameterMismatch,
+  HeadObjectRequest$: () => HeadObjectRequest$,
+  HeadObjectOutput$: () => HeadObjectOutput$,
+  HeadObjectCommand: () => HeadObjectCommand,
+  HeadObject$: () => HeadObject$,
+  HeadBucketRequest$: () => HeadBucketRequest$,
+  HeadBucketOutput$: () => HeadBucketOutput$,
+  HeadBucketCommand: () => HeadBucketCommand,
+  HeadBucket$: () => HeadBucket$,
+  Grantee$: () => Grantee$,
+  Grant$: () => Grant$,
+  GlacierJobParameters$: () => GlacierJobParameters$,
+  GetPublicAccessBlockRequest$: () => GetPublicAccessBlockRequest$,
+  GetPublicAccessBlockOutput$: () => GetPublicAccessBlockOutput$,
+  GetPublicAccessBlockCommand: () => GetPublicAccessBlockCommand,
+  GetPublicAccessBlock$: () => GetPublicAccessBlock$,
+  GetObjectTorrentRequest$: () => GetObjectTorrentRequest$,
+  GetObjectTorrentOutput$: () => GetObjectTorrentOutput$,
+  GetObjectTorrentCommand: () => GetObjectTorrentCommand,
+  GetObjectTorrent$: () => GetObjectTorrent$,
+  GetObjectTaggingRequest$: () => GetObjectTaggingRequest$,
+  GetObjectTaggingOutput$: () => GetObjectTaggingOutput$,
+  GetObjectTaggingCommand: () => GetObjectTaggingCommand,
+  GetObjectTagging$: () => GetObjectTagging$,
+  GetObjectRetentionRequest$: () => GetObjectRetentionRequest$,
+  GetObjectRetentionOutput$: () => GetObjectRetentionOutput$,
+  GetObjectRetentionCommand: () => GetObjectRetentionCommand,
+  GetObjectRetention$: () => GetObjectRetention$,
+  GetObjectRequest$: () => GetObjectRequest$,
+  GetObjectOutput$: () => GetObjectOutput$,
+  GetObjectLockConfigurationRequest$: () => GetObjectLockConfigurationRequest$,
+  GetObjectLockConfigurationOutput$: () => GetObjectLockConfigurationOutput$,
+  GetObjectLockConfigurationCommand: () => GetObjectLockConfigurationCommand,
+  GetObjectLockConfiguration$: () => GetObjectLockConfiguration$,
+  GetObjectLegalHoldRequest$: () => GetObjectLegalHoldRequest$,
+  GetObjectLegalHoldOutput$: () => GetObjectLegalHoldOutput$,
+  GetObjectLegalHoldCommand: () => GetObjectLegalHoldCommand,
+  GetObjectLegalHold$: () => GetObjectLegalHold$,
+  GetObjectCommand: () => GetObjectCommand,
+  GetObjectAttributesRequest$: () => GetObjectAttributesRequest$,
+  GetObjectAttributesParts$: () => GetObjectAttributesParts$,
+  GetObjectAttributesOutput$: () => GetObjectAttributesOutput$,
+  GetObjectAttributesCommand: () => GetObjectAttributesCommand,
+  GetObjectAttributes$: () => GetObjectAttributes$,
+  GetObjectAclRequest$: () => GetObjectAclRequest$,
+  GetObjectAclOutput$: () => GetObjectAclOutput$,
+  GetObjectAclCommand: () => GetObjectAclCommand,
+  GetObjectAcl$: () => GetObjectAcl$,
+  GetObject$: () => GetObject$,
+  GetBucketWebsiteRequest$: () => GetBucketWebsiteRequest$,
+  GetBucketWebsiteOutput$: () => GetBucketWebsiteOutput$,
+  GetBucketWebsiteCommand: () => GetBucketWebsiteCommand,
+  GetBucketWebsite$: () => GetBucketWebsite$,
+  GetBucketVersioningRequest$: () => GetBucketVersioningRequest$,
+  GetBucketVersioningOutput$: () => GetBucketVersioningOutput$,
+  GetBucketVersioningCommand: () => GetBucketVersioningCommand,
+  GetBucketVersioning$: () => GetBucketVersioning$,
+  GetBucketTaggingRequest$: () => GetBucketTaggingRequest$,
+  GetBucketTaggingOutput$: () => GetBucketTaggingOutput$,
+  GetBucketTaggingCommand: () => GetBucketTaggingCommand,
+  GetBucketTagging$: () => GetBucketTagging$,
+  GetBucketRequestPaymentRequest$: () => GetBucketRequestPaymentRequest$,
+  GetBucketRequestPaymentOutput$: () => GetBucketRequestPaymentOutput$,
+  GetBucketRequestPaymentCommand: () => GetBucketRequestPaymentCommand,
+  GetBucketRequestPayment$: () => GetBucketRequestPayment$,
+  GetBucketReplicationRequest$: () => GetBucketReplicationRequest$,
+  GetBucketReplicationOutput$: () => GetBucketReplicationOutput$,
+  GetBucketReplicationCommand: () => GetBucketReplicationCommand,
+  GetBucketReplication$: () => GetBucketReplication$,
+  GetBucketPolicyStatusRequest$: () => GetBucketPolicyStatusRequest$,
+  GetBucketPolicyStatusOutput$: () => GetBucketPolicyStatusOutput$,
+  GetBucketPolicyStatusCommand: () => GetBucketPolicyStatusCommand,
+  GetBucketPolicyStatus$: () => GetBucketPolicyStatus$,
+  GetBucketPolicyRequest$: () => GetBucketPolicyRequest$,
+  GetBucketPolicyOutput$: () => GetBucketPolicyOutput$,
+  GetBucketPolicyCommand: () => GetBucketPolicyCommand,
+  GetBucketPolicy$: () => GetBucketPolicy$,
+  GetBucketOwnershipControlsRequest$: () => GetBucketOwnershipControlsRequest$,
+  GetBucketOwnershipControlsOutput$: () => GetBucketOwnershipControlsOutput$,
+  GetBucketOwnershipControlsCommand: () => GetBucketOwnershipControlsCommand,
+  GetBucketOwnershipControls$: () => GetBucketOwnershipControls$,
+  GetBucketNotificationConfigurationRequest$: () => GetBucketNotificationConfigurationRequest$,
+  GetBucketNotificationConfigurationCommand: () => GetBucketNotificationConfigurationCommand,
+  GetBucketNotificationConfiguration$: () => GetBucketNotificationConfiguration$,
+  GetBucketMetricsConfigurationRequest$: () => GetBucketMetricsConfigurationRequest$,
+  GetBucketMetricsConfigurationOutput$: () => GetBucketMetricsConfigurationOutput$,
+  GetBucketMetricsConfigurationCommand: () => GetBucketMetricsConfigurationCommand,
+  GetBucketMetricsConfiguration$: () => GetBucketMetricsConfiguration$,
+  GetBucketMetadataTableConfigurationResult$: () => GetBucketMetadataTableConfigurationResult$,
+  GetBucketMetadataTableConfigurationRequest$: () => GetBucketMetadataTableConfigurationRequest$,
+  GetBucketMetadataTableConfigurationOutput$: () => GetBucketMetadataTableConfigurationOutput$,
+  GetBucketMetadataTableConfigurationCommand: () => GetBucketMetadataTableConfigurationCommand,
+  GetBucketMetadataTableConfiguration$: () => GetBucketMetadataTableConfiguration$,
+  GetBucketMetadataConfigurationResult$: () => GetBucketMetadataConfigurationResult$,
+  GetBucketMetadataConfigurationRequest$: () => GetBucketMetadataConfigurationRequest$,
+  GetBucketMetadataConfigurationOutput$: () => GetBucketMetadataConfigurationOutput$,
+  GetBucketMetadataConfigurationCommand: () => GetBucketMetadataConfigurationCommand,
+  GetBucketMetadataConfiguration$: () => GetBucketMetadataConfiguration$,
+  GetBucketLoggingRequest$: () => GetBucketLoggingRequest$,
+  GetBucketLoggingOutput$: () => GetBucketLoggingOutput$,
+  GetBucketLoggingCommand: () => GetBucketLoggingCommand,
+  GetBucketLogging$: () => GetBucketLogging$,
+  GetBucketLocationRequest$: () => GetBucketLocationRequest$,
+  GetBucketLocationOutput$: () => GetBucketLocationOutput$,
+  GetBucketLocationCommand: () => GetBucketLocationCommand,
+  GetBucketLocation$: () => GetBucketLocation$,
+  GetBucketLifecycleConfigurationRequest$: () => GetBucketLifecycleConfigurationRequest$,
+  GetBucketLifecycleConfigurationOutput$: () => GetBucketLifecycleConfigurationOutput$,
+  GetBucketLifecycleConfigurationCommand: () => GetBucketLifecycleConfigurationCommand,
+  GetBucketLifecycleConfiguration$: () => GetBucketLifecycleConfiguration$,
+  GetBucketInventoryConfigurationRequest$: () => GetBucketInventoryConfigurationRequest$,
+  GetBucketInventoryConfigurationOutput$: () => GetBucketInventoryConfigurationOutput$,
+  GetBucketInventoryConfigurationCommand: () => GetBucketInventoryConfigurationCommand,
+  GetBucketInventoryConfiguration$: () => GetBucketInventoryConfiguration$,
+  GetBucketIntelligentTieringConfigurationRequest$: () => GetBucketIntelligentTieringConfigurationRequest$,
+  GetBucketIntelligentTieringConfigurationOutput$: () => GetBucketIntelligentTieringConfigurationOutput$,
+  GetBucketIntelligentTieringConfigurationCommand: () => GetBucketIntelligentTieringConfigurationCommand,
+  GetBucketIntelligentTieringConfiguration$: () => GetBucketIntelligentTieringConfiguration$,
+  GetBucketEncryptionRequest$: () => GetBucketEncryptionRequest$,
+  GetBucketEncryptionOutput$: () => GetBucketEncryptionOutput$,
+  GetBucketEncryptionCommand: () => GetBucketEncryptionCommand,
+  GetBucketEncryption$: () => GetBucketEncryption$,
+  GetBucketCorsRequest$: () => GetBucketCorsRequest$,
+  GetBucketCorsOutput$: () => GetBucketCorsOutput$,
+  GetBucketCorsCommand: () => GetBucketCorsCommand,
+  GetBucketCors$: () => GetBucketCors$,
+  GetBucketAnalyticsConfigurationRequest$: () => GetBucketAnalyticsConfigurationRequest$,
+  GetBucketAnalyticsConfigurationOutput$: () => GetBucketAnalyticsConfigurationOutput$,
+  GetBucketAnalyticsConfigurationCommand: () => GetBucketAnalyticsConfigurationCommand,
+  GetBucketAnalyticsConfiguration$: () => GetBucketAnalyticsConfiguration$,
+  GetBucketAclRequest$: () => GetBucketAclRequest$,
+  GetBucketAclOutput$: () => GetBucketAclOutput$,
+  GetBucketAclCommand: () => GetBucketAclCommand,
+  GetBucketAcl$: () => GetBucketAcl$,
+  GetBucketAccelerateConfigurationRequest$: () => GetBucketAccelerateConfigurationRequest$,
+  GetBucketAccelerateConfigurationOutput$: () => GetBucketAccelerateConfigurationOutput$,
+  GetBucketAccelerateConfigurationCommand: () => GetBucketAccelerateConfigurationCommand,
+  GetBucketAccelerateConfiguration$: () => GetBucketAccelerateConfiguration$,
+  GetBucketAbacRequest$: () => GetBucketAbacRequest$,
+  GetBucketAbacOutput$: () => GetBucketAbacOutput$,
+  GetBucketAbacCommand: () => GetBucketAbacCommand,
+  GetBucketAbac$: () => GetBucketAbac$,
+  FilterRuleName: () => FilterRuleName,
+  FilterRule$: () => FilterRule$,
+  FileHeaderInfo: () => FileHeaderInfo,
+  ExpressionType: () => ExpressionType,
+  ExpirationStatus: () => ExpirationStatus,
+  ExpirationState: () => ExpirationState,
+  ExistingObjectReplicationStatus: () => ExistingObjectReplicationStatus,
+  ExistingObjectReplication$: () => ExistingObjectReplication$,
+  EventBridgeConfiguration$: () => EventBridgeConfiguration$,
+  Event: () => Event,
+  ErrorDocument$: () => ErrorDocument$,
+  ErrorDetails$: () => ErrorDetails$,
+  EndEvent$: () => EndEvent$,
+  EncryptionTypeMismatch$: () => EncryptionTypeMismatch$,
+  EncryptionTypeMismatch: () => EncryptionTypeMismatch,
+  EncryptionType: () => EncryptionType,
+  EncryptionConfiguration$: () => EncryptionConfiguration$,
+  Encryption$: () => Encryption$,
+  EncodingType: () => EncodingType,
+  DestinationResult$: () => DestinationResult$,
+  Destination$: () => Destination$,
+  DeletedObject$: () => DeletedObject$,
+  DeletePublicAccessBlockRequest$: () => DeletePublicAccessBlockRequest$,
+  DeletePublicAccessBlockCommand: () => DeletePublicAccessBlockCommand,
+  DeletePublicAccessBlock$: () => DeletePublicAccessBlock$,
+  DeleteObjectsRequest$: () => DeleteObjectsRequest$,
+  DeleteObjectsOutput$: () => DeleteObjectsOutput$,
+  DeleteObjectsCommand: () => DeleteObjectsCommand,
+  DeleteObjects$: () => DeleteObjects$,
+  DeleteObjectTaggingRequest$: () => DeleteObjectTaggingRequest$,
+  DeleteObjectTaggingOutput$: () => DeleteObjectTaggingOutput$,
+  DeleteObjectTaggingCommand: () => DeleteObjectTaggingCommand,
+  DeleteObjectTagging$: () => DeleteObjectTagging$,
+  DeleteObjectRequest$: () => DeleteObjectRequest$,
+  DeleteObjectOutput$: () => DeleteObjectOutput$,
+  DeleteObjectCommand: () => DeleteObjectCommand,
+  DeleteObject$: () => DeleteObject$,
+  DeleteMarkerReplicationStatus: () => DeleteMarkerReplicationStatus,
+  DeleteMarkerReplication$: () => DeleteMarkerReplication$,
+  DeleteMarkerEntry$: () => DeleteMarkerEntry$,
+  DeleteBucketWebsiteRequest$: () => DeleteBucketWebsiteRequest$,
+  DeleteBucketWebsiteCommand: () => DeleteBucketWebsiteCommand,
+  DeleteBucketWebsite$: () => DeleteBucketWebsite$,
+  DeleteBucketTaggingRequest$: () => DeleteBucketTaggingRequest$,
+  DeleteBucketTaggingCommand: () => DeleteBucketTaggingCommand,
+  DeleteBucketTagging$: () => DeleteBucketTagging$,
+  DeleteBucketRequest$: () => DeleteBucketRequest$,
+  DeleteBucketReplicationRequest$: () => DeleteBucketReplicationRequest$,
+  DeleteBucketReplicationCommand: () => DeleteBucketReplicationCommand,
+  DeleteBucketReplication$: () => DeleteBucketReplication$,
+  DeleteBucketPolicyRequest$: () => DeleteBucketPolicyRequest$,
+  DeleteBucketPolicyCommand: () => DeleteBucketPolicyCommand,
+  DeleteBucketPolicy$: () => DeleteBucketPolicy$,
+  DeleteBucketOwnershipControlsRequest$: () => DeleteBucketOwnershipControlsRequest$,
+  DeleteBucketOwnershipControlsCommand: () => DeleteBucketOwnershipControlsCommand,
+  DeleteBucketOwnershipControls$: () => DeleteBucketOwnershipControls$,
+  DeleteBucketMetricsConfigurationRequest$: () => DeleteBucketMetricsConfigurationRequest$,
+  DeleteBucketMetricsConfigurationCommand: () => DeleteBucketMetricsConfigurationCommand,
+  DeleteBucketMetricsConfiguration$: () => DeleteBucketMetricsConfiguration$,
+  DeleteBucketMetadataTableConfigurationRequest$: () => DeleteBucketMetadataTableConfigurationRequest$,
+  DeleteBucketMetadataTableConfigurationCommand: () => DeleteBucketMetadataTableConfigurationCommand,
+  DeleteBucketMetadataTableConfiguration$: () => DeleteBucketMetadataTableConfiguration$,
+  DeleteBucketMetadataConfigurationRequest$: () => DeleteBucketMetadataConfigurationRequest$,
+  DeleteBucketMetadataConfigurationCommand: () => DeleteBucketMetadataConfigurationCommand,
+  DeleteBucketMetadataConfiguration$: () => DeleteBucketMetadataConfiguration$,
+  DeleteBucketLifecycleRequest$: () => DeleteBucketLifecycleRequest$,
+  DeleteBucketLifecycleCommand: () => DeleteBucketLifecycleCommand,
+  DeleteBucketLifecycle$: () => DeleteBucketLifecycle$,
+  DeleteBucketInventoryConfigurationRequest$: () => DeleteBucketInventoryConfigurationRequest$,
+  DeleteBucketInventoryConfigurationCommand: () => DeleteBucketInventoryConfigurationCommand,
+  DeleteBucketInventoryConfiguration$: () => DeleteBucketInventoryConfiguration$,
+  DeleteBucketIntelligentTieringConfigurationRequest$: () => DeleteBucketIntelligentTieringConfigurationRequest$,
+  DeleteBucketIntelligentTieringConfigurationCommand: () => DeleteBucketIntelligentTieringConfigurationCommand,
+  DeleteBucketIntelligentTieringConfiguration$: () => DeleteBucketIntelligentTieringConfiguration$,
+  DeleteBucketEncryptionRequest$: () => DeleteBucketEncryptionRequest$,
+  DeleteBucketEncryptionCommand: () => DeleteBucketEncryptionCommand,
+  DeleteBucketEncryption$: () => DeleteBucketEncryption$,
+  DeleteBucketCorsRequest$: () => DeleteBucketCorsRequest$,
+  DeleteBucketCorsCommand: () => DeleteBucketCorsCommand,
+  DeleteBucketCors$: () => DeleteBucketCors$,
+  DeleteBucketCommand: () => DeleteBucketCommand,
+  DeleteBucketAnalyticsConfigurationRequest$: () => DeleteBucketAnalyticsConfigurationRequest$,
+  DeleteBucketAnalyticsConfigurationCommand: () => DeleteBucketAnalyticsConfigurationCommand,
+  DeleteBucketAnalyticsConfiguration$: () => DeleteBucketAnalyticsConfiguration$,
+  DeleteBucket$: () => DeleteBucket$,
+  Delete$: () => Delete$,
+  DefaultRetention$: () => DefaultRetention$,
+  DataRedundancy: () => DataRedundancy,
+  CreateSessionRequest$: () => CreateSessionRequest$,
+  CreateSessionOutput$: () => CreateSessionOutput$,
+  CreateSessionCommand: () => CreateSessionCommand,
+  CreateSession$: () => CreateSession$,
+  CreateMultipartUploadRequest$: () => CreateMultipartUploadRequest$,
+  CreateMultipartUploadOutput$: () => CreateMultipartUploadOutput$,
+  CreateMultipartUploadCommand: () => CreateMultipartUploadCommand,
+  CreateMultipartUpload$: () => CreateMultipartUpload$,
+  CreateBucketRequest$: () => CreateBucketRequest$,
+  CreateBucketOutput$: () => CreateBucketOutput$,
+  CreateBucketMetadataTableConfigurationRequest$: () => CreateBucketMetadataTableConfigurationRequest$,
+  CreateBucketMetadataTableConfigurationCommand: () => CreateBucketMetadataTableConfigurationCommand,
+  CreateBucketMetadataTableConfiguration$: () => CreateBucketMetadataTableConfiguration$,
+  CreateBucketMetadataConfigurationRequest$: () => CreateBucketMetadataConfigurationRequest$,
+  CreateBucketMetadataConfigurationCommand: () => CreateBucketMetadataConfigurationCommand,
+  CreateBucketMetadataConfiguration$: () => CreateBucketMetadataConfiguration$,
+  CreateBucketConfiguration$: () => CreateBucketConfiguration$,
+  CreateBucketCommand: () => CreateBucketCommand,
+  CreateBucket$: () => CreateBucket$,
+  CopyPartResult$: () => CopyPartResult$,
+  CopyObjectResult$: () => CopyObjectResult$,
+  CopyObjectRequest$: () => CopyObjectRequest$,
+  CopyObjectOutput$: () => CopyObjectOutput$,
+  CopyObjectCommand: () => CopyObjectCommand,
+  CopyObject$: () => CopyObject$,
+  ContinuationEvent$: () => ContinuationEvent$,
+  Condition$: () => Condition$,
+  CompressionType: () => CompressionType,
+  CompletedPart$: () => CompletedPart$,
+  CompletedMultipartUpload$: () => CompletedMultipartUpload$,
+  CompleteMultipartUploadRequest$: () => CompleteMultipartUploadRequest$,
+  CompleteMultipartUploadOutput$: () => CompleteMultipartUploadOutput$,
+  CompleteMultipartUploadCommand: () => CompleteMultipartUploadCommand,
+  CompleteMultipartUpload$: () => CompleteMultipartUpload$,
+  CommonPrefix$: () => CommonPrefix$,
+  ChecksumType: () => ChecksumType,
+  ChecksumMode: () => ChecksumMode,
+  ChecksumAlgorithm: () => ChecksumAlgorithm2,
+  Checksum$: () => Checksum$,
+  CSVOutput$: () => CSVOutput$,
+  CSVInput$: () => CSVInput$,
+  CORSRule$: () => CORSRule$,
+  CORSConfiguration$: () => CORSConfiguration$,
+  BucketVersioningStatus: () => BucketVersioningStatus,
+  BucketType: () => BucketType,
+  BucketNamespace: () => BucketNamespace,
+  BucketLogsPermission: () => BucketLogsPermission,
+  BucketLoggingStatus$: () => BucketLoggingStatus$,
+  BucketLocationConstraint: () => BucketLocationConstraint,
+  BucketLifecycleConfiguration$: () => BucketLifecycleConfiguration$,
+  BucketInfo$: () => BucketInfo$,
+  BucketCannedACL: () => BucketCannedACL,
+  BucketAlreadyOwnedByYou$: () => BucketAlreadyOwnedByYou$,
+  BucketAlreadyOwnedByYou: () => BucketAlreadyOwnedByYou,
+  BucketAlreadyExists$: () => BucketAlreadyExists$,
+  BucketAlreadyExists: () => BucketAlreadyExists,
+  BucketAccelerateStatus: () => BucketAccelerateStatus,
+  BucketAbacStatus: () => BucketAbacStatus,
+  Bucket$: () => Bucket$,
+  BlockedEncryptionTypes$: () => BlockedEncryptionTypes$,
+  ArchiveStatus: () => ArchiveStatus,
+  AnalyticsS3ExportFileFormat: () => AnalyticsS3ExportFileFormat,
+  AnalyticsS3BucketDestination$: () => AnalyticsS3BucketDestination$,
+  AnalyticsFilter$: () => AnalyticsFilter$,
+  AnalyticsExportDestination$: () => AnalyticsExportDestination$,
+  AnalyticsConfiguration$: () => AnalyticsConfiguration$,
+  AnalyticsAndOperator$: () => AnalyticsAndOperator$,
+  AccessDenied$: () => AccessDenied$,
+  AccessDenied: () => AccessDenied,
+  AccessControlTranslation$: () => AccessControlTranslation$,
+  AccessControlPolicy$: () => AccessControlPolicy$,
+  AccelerateConfiguration$: () => AccelerateConfiguration$,
+  AbortMultipartUploadRequest$: () => AbortMultipartUploadRequest$,
+  AbortMultipartUploadOutput$: () => AbortMultipartUploadOutput$,
+  AbortMultipartUploadCommand: () => AbortMultipartUploadCommand,
+  AbortMultipartUpload$: () => AbortMultipartUpload$,
+  AbortIncompleteMultipartUpload$: () => AbortIncompleteMultipartUpload$,
+  AbacStatus$: () => AbacStatus$
+});
 var init_dist_es27 = __esm(() => {
+  init_S3ServiceException();
   init_S3Client();
   init_S3();
   init_commands();
@@ -44297,11 +45839,39 @@ var init_s3 = __esm(() => {
   init_sources();
 });
 
+// src/db/resolve.ts
+var exports_resolve = {};
+__export(exports_resolve, {
+  resolveId: () => resolveId,
+  requireId: () => requireId
+});
+function resolveId(partial, table) {
+  const db2 = getDb();
+  const exact = db2.query(`SELECT id FROM ${table} WHERE id = ?`).get(partial);
+  if (exact)
+    return exact.id;
+  const matches = db2.query(`SELECT id FROM ${table} WHERE id LIKE ?`).all(`${partial}%`);
+  if (matches.length === 1)
+    return matches[0].id;
+  if (matches.length > 1)
+    throw new Error(`Ambiguous ID "${partial}" matches ${matches.length} ${table}: ${matches.map((m2) => m2.id).join(", ")}`);
+  return null;
+}
+function requireId(partial, table) {
+  const id = resolveId(partial, table);
+  if (!id)
+    throw new Error(`No ${table.slice(0, -1)} found matching "${partial}"`);
+  return id;
+}
+var init_resolve = __esm(() => {
+  init_database();
+});
+
 // package.json
 var require_package2 = __commonJS((exports, module) => {
   module.exports = {
     name: "@hasna/files",
-    version: "0.2.0",
+    version: "0.2.1",
     description: "Agent-first file management \u2014 index local folders and S3 buckets, tag, search, and retrieve files via CLI + MCP",
     type: "module",
     main: "dist/index.js",
@@ -44380,6 +45950,1628 @@ var require_package2 = __commonJS((exports, module) => {
   };
 });
 
+// node_modules/readdirp/esm/index.js
+import { stat, lstat, readdir, realpath } from "fs/promises";
+import { Readable as Readable3 } from "stream";
+import { resolve as presolve, relative as prelative, join as pjoin, sep as psep } from "path";
+function readdirp(root, options = {}) {
+  let type = options.entryType || options.type;
+  if (type === "both")
+    type = EntryTypes.FILE_DIR_TYPE;
+  if (type)
+    options.type = type;
+  if (!root) {
+    throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");
+  } else if (typeof root !== "string") {
+    throw new TypeError("readdirp: root argument must be a string. Usage: readdirp(root, options)");
+  } else if (type && !ALL_TYPES.includes(type)) {
+    throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`);
+  }
+  options.root = root;
+  return new ReaddirpStream(options);
+}
+var EntryTypes, defaultOptions, RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR", NORMAL_FLOW_ERRORS, ALL_TYPES, DIR_TYPES, FILE_TYPES, isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code), wantBigintFsStats, emptyFn = (_entryInfo) => true, normalizeFilter = (filter) => {
+  if (filter === undefined)
+    return emptyFn;
+  if (typeof filter === "function")
+    return filter;
+  if (typeof filter === "string") {
+    const fl = filter.trim();
+    return (entry) => entry.basename === fl;
+  }
+  if (Array.isArray(filter)) {
+    const trItems = filter.map((item) => item.trim());
+    return (entry) => trItems.some((f2) => entry.basename === f2);
+  }
+  return emptyFn;
+}, ReaddirpStream;
+var init_esm2 = __esm(() => {
+  EntryTypes = {
+    FILE_TYPE: "files",
+    DIR_TYPE: "directories",
+    FILE_DIR_TYPE: "files_directories",
+    EVERYTHING_TYPE: "all"
+  };
+  defaultOptions = {
+    root: ".",
+    fileFilter: (_entryInfo) => true,
+    directoryFilter: (_entryInfo) => true,
+    type: EntryTypes.FILE_TYPE,
+    lstat: false,
+    depth: 2147483648,
+    alwaysStat: false,
+    highWaterMark: 4096
+  };
+  Object.freeze(defaultOptions);
+  NORMAL_FLOW_ERRORS = new Set(["ENOENT", "EPERM", "EACCES", "ELOOP", RECURSIVE_ERROR_CODE]);
+  ALL_TYPES = [
+    EntryTypes.DIR_TYPE,
+    EntryTypes.EVERYTHING_TYPE,
+    EntryTypes.FILE_DIR_TYPE,
+    EntryTypes.FILE_TYPE
+  ];
+  DIR_TYPES = new Set([
+    EntryTypes.DIR_TYPE,
+    EntryTypes.EVERYTHING_TYPE,
+    EntryTypes.FILE_DIR_TYPE
+  ]);
+  FILE_TYPES = new Set([
+    EntryTypes.EVERYTHING_TYPE,
+    EntryTypes.FILE_DIR_TYPE,
+    EntryTypes.FILE_TYPE
+  ]);
+  wantBigintFsStats = process.platform === "win32";
+  ReaddirpStream = class ReaddirpStream extends Readable3 {
+    constructor(options = {}) {
+      super({
+        objectMode: true,
+        autoDestroy: true,
+        highWaterMark: options.highWaterMark
+      });
+      const opts = { ...defaultOptions, ...options };
+      const { root, type } = opts;
+      this._fileFilter = normalizeFilter(opts.fileFilter);
+      this._directoryFilter = normalizeFilter(opts.directoryFilter);
+      const statMethod = opts.lstat ? lstat : stat;
+      if (wantBigintFsStats) {
+        this._stat = (path) => statMethod(path, { bigint: true });
+      } else {
+        this._stat = statMethod;
+      }
+      this._maxDepth = opts.depth ?? defaultOptions.depth;
+      this._wantsDir = type ? DIR_TYPES.has(type) : false;
+      this._wantsFile = type ? FILE_TYPES.has(type) : false;
+      this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
+      this._root = presolve(root);
+      this._isDirent = !opts.alwaysStat;
+      this._statsProp = this._isDirent ? "dirent" : "stats";
+      this._rdOptions = { encoding: "utf8", withFileTypes: this._isDirent };
+      this.parents = [this._exploreDir(root, 1)];
+      this.reading = false;
+      this.parent = undefined;
+    }
+    async _read(batch) {
+      if (this.reading)
+        return;
+      this.reading = true;
+      try {
+        while (!this.destroyed && batch > 0) {
+          const par = this.parent;
+          const fil = par && par.files;
+          if (fil && fil.length > 0) {
+            const { path, depth } = par;
+            const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path));
+            const awaited = await Promise.all(slice);
+            for (const entry of awaited) {
+              if (!entry)
+                continue;
+              if (this.destroyed)
+                return;
+              const entryType = await this._getEntryType(entry);
+              if (entryType === "directory" && this._directoryFilter(entry)) {
+                if (depth <= this._maxDepth) {
+                  this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+                }
+                if (this._wantsDir) {
+                  this.push(entry);
+                  batch--;
+                }
+              } else if ((entryType === "file" || this._includeAsFile(entry)) && this._fileFilter(entry)) {
+                if (this._wantsFile) {
+                  this.push(entry);
+                  batch--;
+                }
+              }
+            }
+          } else {
+            const parent = this.parents.pop();
+            if (!parent) {
+              this.push(null);
+              break;
+            }
+            this.parent = await parent;
+            if (this.destroyed)
+              return;
+          }
+        }
+      } catch (error) {
+        this.destroy(error);
+      } finally {
+        this.reading = false;
+      }
+    }
+    async _exploreDir(path, depth) {
+      let files;
+      try {
+        files = await readdir(path, this._rdOptions);
+      } catch (error) {
+        this._onError(error);
+      }
+      return { files, depth, path };
+    }
+    async _formatEntry(dirent, path) {
+      let entry;
+      const basename4 = this._isDirent ? dirent.name : dirent;
+      try {
+        const fullPath = presolve(pjoin(path, basename4));
+        entry = { path: prelative(this._root, fullPath), fullPath, basename: basename4 };
+        entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+      } catch (err) {
+        this._onError(err);
+        return;
+      }
+      return entry;
+    }
+    _onError(err) {
+      if (isNormalFlowError(err) && !this.destroyed) {
+        this.emit("warn", err);
+      } else {
+        this.destroy(err);
+      }
+    }
+    async _getEntryType(entry) {
+      if (!entry && this._statsProp in entry) {
+        return "";
+      }
+      const stats = entry[this._statsProp];
+      if (stats.isFile())
+        return "file";
+      if (stats.isDirectory())
+        return "directory";
+      if (stats && stats.isSymbolicLink()) {
+        const full = entry.fullPath;
+        try {
+          const entryRealPath = await realpath(full);
+          const entryRealPathStats = await lstat(entryRealPath);
+          if (entryRealPathStats.isFile()) {
+            return "file";
+          }
+          if (entryRealPathStats.isDirectory()) {
+            const len = entryRealPath.length;
+            if (full.startsWith(entryRealPath) && full.substr(len, 1) === psep) {
+              const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+              recursiveError.code = RECURSIVE_ERROR_CODE;
+              return this._onError(recursiveError);
+            }
+            return "directory";
+          }
+        } catch (error) {
+          this._onError(error);
+          return "";
+        }
+      }
+    }
+    _includeAsFile(entry) {
+      const stats = entry && entry[this._statsProp];
+      return stats && this._wantsEverything && !stats.isDirectory();
+    }
+  };
+});
+
+// node_modules/chokidar/esm/handler.js
+import { watchFile, unwatchFile, watch as fs_watch } from "fs";
+import { open, stat as stat2, lstat as lstat2, realpath as fsrealpath } from "fs/promises";
+import * as sysPath from "path";
+import { type as osType } from "os";
+function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
+  const handleEvent = (rawEvent, evPath) => {
+    listener(path);
+    emitRaw(rawEvent, evPath, { watchedPath: path });
+    if (evPath && path !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path, evPath), KEY_LISTENERS, sysPath.join(path, evPath));
+    }
+  };
+  try {
+    return fs_watch(path, {
+      persistent: options.persistent
+    }, handleEvent);
+  } catch (error) {
+    errHandler(error);
+    return;
+  }
+}
+
+class NodeFsHandler {
+  constructor(fsW) {
+    this.fsw = fsW;
+    this._boundHandleError = (error) => fsW._handleError(error);
+  }
+  _watchWithNodeFs(path, listener) {
+    const opts = this.fsw.options;
+    const directory = sysPath.dirname(path);
+    const basename5 = sysPath.basename(path);
+    const parent = this.fsw._getWatchedDir(directory);
+    parent.add(basename5);
+    const absolutePath = sysPath.resolve(path);
+    const options = {
+      persistent: opts.persistent
+    };
+    if (!listener)
+      listener = EMPTY_FN;
+    let closer;
+    if (opts.usePolling) {
+      const enableBin = opts.interval !== opts.binaryInterval;
+      options.interval = enableBin && isBinaryPath(basename5) ? opts.binaryInterval : opts.interval;
+      closer = setFsWatchFileListener(path, absolutePath, options, {
+        listener,
+        rawEmitter: this.fsw._emitRaw
+      });
+    } else {
+      closer = setFsWatchListener(path, absolutePath, options, {
+        listener,
+        errHandler: this._boundHandleError,
+        rawEmitter: this.fsw._emitRaw
+      });
+    }
+    return closer;
+  }
+  _handleFile(file, stats, initialAdd) {
+    if (this.fsw.closed) {
+      return;
+    }
+    const dirname4 = sysPath.dirname(file);
+    const basename5 = sysPath.basename(file);
+    const parent = this.fsw._getWatchedDir(dirname4);
+    let prevStats = stats;
+    if (parent.has(basename5))
+      return;
+    const listener = async (path, newStats) => {
+      if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
+        return;
+      if (!newStats || newStats.mtimeMs === 0) {
+        try {
+          const newStats2 = await stat2(file);
+          if (this.fsw.closed)
+            return;
+          const at2 = newStats2.atimeMs;
+          const mt = newStats2.mtimeMs;
+          if (!at2 || at2 <= mt || mt !== prevStats.mtimeMs) {
+            this.fsw._emit(EV.CHANGE, file, newStats2);
+          }
+          if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
+            this.fsw._closeFile(path);
+            prevStats = newStats2;
+            const closer2 = this._watchWithNodeFs(file, listener);
+            if (closer2)
+              this.fsw._addPathCloser(path, closer2);
+          } else {
+            prevStats = newStats2;
+          }
+        } catch (error) {
+          this.fsw._remove(dirname4, basename5);
+        }
+      } else if (parent.has(basename5)) {
+        const at2 = newStats.atimeMs;
+        const mt = newStats.mtimeMs;
+        if (!at2 || at2 <= mt || mt !== prevStats.mtimeMs) {
+          this.fsw._emit(EV.CHANGE, file, newStats);
+        }
+        prevStats = newStats;
+      }
+    };
+    const closer = this._watchWithNodeFs(file, listener);
+    if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
+      if (!this.fsw._throttle(EV.ADD, file, 0))
+        return;
+      this.fsw._emit(EV.ADD, file, stats);
+    }
+    return closer;
+  }
+  async _handleSymlink(entry, directory, path, item) {
+    if (this.fsw.closed) {
+      return;
+    }
+    const full = entry.fullPath;
+    const dir = this.fsw._getWatchedDir(directory);
+    if (!this.fsw.options.followSymlinks) {
+      this.fsw._incrReadyCount();
+      let linkPath;
+      try {
+        linkPath = await fsrealpath(path);
+      } catch (e2) {
+        this.fsw._emitReady();
+        return true;
+      }
+      if (this.fsw.closed)
+        return;
+      if (dir.has(item)) {
+        if (this.fsw._symlinkPaths.get(full) !== linkPath) {
+          this.fsw._symlinkPaths.set(full, linkPath);
+          this.fsw._emit(EV.CHANGE, path, entry.stats);
+        }
+      } else {
+        dir.add(item);
+        this.fsw._symlinkPaths.set(full, linkPath);
+        this.fsw._emit(EV.ADD, path, entry.stats);
+      }
+      this.fsw._emitReady();
+      return true;
+    }
+    if (this.fsw._symlinkPaths.has(full)) {
+      return true;
+    }
+    this.fsw._symlinkPaths.set(full, true);
+  }
+  _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
+    directory = sysPath.join(directory, "");
+    throttler = this.fsw._throttle("readdir", directory, 1000);
+    if (!throttler)
+      return;
+    const previous = this.fsw._getWatchedDir(wh.path);
+    const current = new Set;
+    let stream = this.fsw._readdirp(directory, {
+      fileFilter: (entry) => wh.filterPath(entry),
+      directoryFilter: (entry) => wh.filterDir(entry)
+    });
+    if (!stream)
+      return;
+    stream.on(STR_DATA, async (entry) => {
+      if (this.fsw.closed) {
+        stream = undefined;
+        return;
+      }
+      const item = entry.path;
+      let path = sysPath.join(directory, item);
+      current.add(item);
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path, item)) {
+        return;
+      }
+      if (this.fsw.closed) {
+        stream = undefined;
+        return;
+      }
+      if (item === target || !target && !previous.has(item)) {
+        this.fsw._incrReadyCount();
+        path = sysPath.join(dir, sysPath.relative(dir, path));
+        this._addToNodeFs(path, initialAdd, wh, depth + 1);
+      }
+    }).on(EV.ERROR, this._boundHandleError);
+    return new Promise((resolve2, reject) => {
+      if (!stream)
+        return reject();
+      stream.once(STR_END, () => {
+        if (this.fsw.closed) {
+          stream = undefined;
+          return;
+        }
+        const wasThrottled = throttler ? throttler.clear() : false;
+        resolve2(undefined);
+        previous.getChildren().filter((item) => {
+          return item !== directory && !current.has(item);
+        }).forEach((item) => {
+          this.fsw._remove(directory, item);
+        });
+        stream = undefined;
+        if (wasThrottled)
+          this._handleRead(directory, false, wh, target, dir, depth, throttler);
+      });
+    });
+  }
+  async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath2) {
+    const parentDir = this.fsw._getWatchedDir(sysPath.dirname(dir));
+    const tracked = parentDir.has(sysPath.basename(dir));
+    if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
+      this.fsw._emit(EV.ADD_DIR, dir, stats);
+    }
+    parentDir.add(sysPath.basename(dir));
+    this.fsw._getWatchedDir(dir);
+    let throttler;
+    let closer;
+    const oDepth = this.fsw.options.depth;
+    if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath2)) {
+      if (!target) {
+        await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
+        if (this.fsw.closed)
+          return;
+      }
+      closer = this._watchWithNodeFs(dir, (dirPath, stats2) => {
+        if (stats2 && stats2.mtimeMs === 0)
+          return;
+        this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
+      });
+    }
+    return closer;
+  }
+  async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
+    const ready = this.fsw._emitReady;
+    if (this.fsw._isIgnored(path) || this.fsw.closed) {
+      ready();
+      return false;
+    }
+    const wh = this.fsw._getWatchHelpers(path);
+    if (priorWh) {
+      wh.filterPath = (entry) => priorWh.filterPath(entry);
+      wh.filterDir = (entry) => priorWh.filterDir(entry);
+    }
+    try {
+      const stats = await statMethods[wh.statMethod](wh.watchPath);
+      if (this.fsw.closed)
+        return;
+      if (this.fsw._isIgnored(wh.watchPath, stats)) {
+        ready();
+        return false;
+      }
+      const follow = this.fsw.options.followSymlinks;
+      let closer;
+      if (stats.isDirectory()) {
+        const absPath = sysPath.resolve(path);
+        const targetPath = follow ? await fsrealpath(path) : path;
+        if (this.fsw.closed)
+          return;
+        closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
+        if (this.fsw.closed)
+          return;
+        if (absPath !== targetPath && targetPath !== undefined) {
+          this.fsw._symlinkPaths.set(absPath, targetPath);
+        }
+      } else if (stats.isSymbolicLink()) {
+        const targetPath = follow ? await fsrealpath(path) : path;
+        if (this.fsw.closed)
+          return;
+        const parent = sysPath.dirname(wh.watchPath);
+        this.fsw._getWatchedDir(parent).add(wh.watchPath);
+        this.fsw._emit(EV.ADD, wh.watchPath, stats);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath);
+        if (this.fsw.closed)
+          return;
+        if (targetPath !== undefined) {
+          this.fsw._symlinkPaths.set(sysPath.resolve(path), targetPath);
+        }
+      } else {
+        closer = this._handleFile(wh.watchPath, stats, initialAdd);
+      }
+      ready();
+      if (closer)
+        this.fsw._addPathCloser(path, closer);
+      return false;
+    } catch (error) {
+      if (this.fsw._handleError(error)) {
+        ready();
+        return path;
+      }
+    }
+  }
+}
+var STR_DATA = "data", STR_END = "end", STR_CLOSE = "close", EMPTY_FN = () => {}, pl, isWindows, isMacos, isLinux, isFreeBSD, isIBMi, EVENTS, EV, THROTTLE_MODE_WATCH = "watch", statMethods, KEY_LISTENERS = "listeners", KEY_ERR = "errHandlers", KEY_RAW = "rawEmitters", HANDLER_KEYS, binaryExtensions, isBinaryPath = (filePath) => binaryExtensions.has(sysPath.extname(filePath).slice(1).toLowerCase()), foreach = (val, fn) => {
+  if (val instanceof Set) {
+    val.forEach(fn);
+  } else {
+    fn(val);
+  }
+}, addAndConvert = (main, prop, item) => {
+  let container = main[prop];
+  if (!(container instanceof Set)) {
+    main[prop] = container = new Set([container]);
+  }
+  container.add(item);
+}, clearItem = (cont) => (key) => {
+  const set = cont[key];
+  if (set instanceof Set) {
+    set.clear();
+  } else {
+    delete cont[key];
+  }
+}, delFromSet = (main, prop, item) => {
+  const container = main[prop];
+  if (container instanceof Set) {
+    container.delete(item);
+  } else if (container === item) {
+    delete main[prop];
+  }
+}, isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val, FsWatchInstances, fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
+  const cont = FsWatchInstances.get(fullPath);
+  if (!cont)
+    return;
+  foreach(cont[listenerType], (listener) => {
+    listener(val1, val2, val3);
+  });
+}, setFsWatchListener = (path, fullPath, options, handlers) => {
+  const { listener, errHandler, rawEmitter } = handlers;
+  let cont = FsWatchInstances.get(fullPath);
+  let watcher;
+  if (!options.persistent) {
+    watcher = createFsWatchInstance(path, options, listener, errHandler, rawEmitter);
+    if (!watcher)
+      return;
+    return watcher.close.bind(watcher);
+  }
+  if (cont) {
+    addAndConvert(cont, KEY_LISTENERS, listener);
+    addAndConvert(cont, KEY_ERR, errHandler);
+    addAndConvert(cont, KEY_RAW, rawEmitter);
+  } else {
+    watcher = createFsWatchInstance(path, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
+    if (!watcher)
+      return;
+    watcher.on(EV.ERROR, async (error) => {
+      const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
+      if (cont)
+        cont.watcherUnusable = true;
+      if (isWindows && error.code === "EPERM") {
+        try {
+          const fd = await open(path, "r");
+          await fd.close();
+          broadcastErr(error);
+        } catch (err) {}
+      } else {
+        broadcastErr(error);
+      }
+    });
+    cont = {
+      listeners: listener,
+      errHandlers: errHandler,
+      rawEmitters: rawEmitter,
+      watcher
+    };
+    FsWatchInstances.set(fullPath, cont);
+  }
+  return () => {
+    delFromSet(cont, KEY_LISTENERS, listener);
+    delFromSet(cont, KEY_ERR, errHandler);
+    delFromSet(cont, KEY_RAW, rawEmitter);
+    if (isEmptySet(cont.listeners)) {
+      cont.watcher.close();
+      FsWatchInstances.delete(fullPath);
+      HANDLER_KEYS.forEach(clearItem(cont));
+      cont.watcher = undefined;
+      Object.freeze(cont);
+    }
+  };
+}, FsWatchFileInstances, setFsWatchFileListener = (path, fullPath, options, handlers) => {
+  const { listener, rawEmitter } = handlers;
+  let cont = FsWatchFileInstances.get(fullPath);
+  const copts = cont && cont.options;
+  if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
+    unwatchFile(fullPath);
+    cont = undefined;
+  }
+  if (cont) {
+    addAndConvert(cont, KEY_LISTENERS, listener);
+    addAndConvert(cont, KEY_RAW, rawEmitter);
+  } else {
+    cont = {
+      listeners: listener,
+      rawEmitters: rawEmitter,
+      options,
+      watcher: watchFile(fullPath, options, (curr, prev) => {
+        foreach(cont.rawEmitters, (rawEmitter2) => {
+          rawEmitter2(EV.CHANGE, fullPath, { curr, prev });
+        });
+        const currmtime = curr.mtimeMs;
+        if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
+          foreach(cont.listeners, (listener2) => listener2(path, curr));
+        }
+      })
+    };
+    FsWatchFileInstances.set(fullPath, cont);
+  }
+  return () => {
+    delFromSet(cont, KEY_LISTENERS, listener);
+    delFromSet(cont, KEY_RAW, rawEmitter);
+    if (isEmptySet(cont.listeners)) {
+      FsWatchFileInstances.delete(fullPath);
+      unwatchFile(fullPath);
+      cont.options = cont.watcher = undefined;
+      Object.freeze(cont);
+    }
+  };
+};
+var init_handler = __esm(() => {
+  pl = process.platform;
+  isWindows = pl === "win32";
+  isMacos = pl === "darwin";
+  isLinux = pl === "linux";
+  isFreeBSD = pl === "freebsd";
+  isIBMi = osType() === "OS400";
+  EVENTS = {
+    ALL: "all",
+    READY: "ready",
+    ADD: "add",
+    CHANGE: "change",
+    ADD_DIR: "addDir",
+    UNLINK: "unlink",
+    UNLINK_DIR: "unlinkDir",
+    RAW: "raw",
+    ERROR: "error"
+  };
+  EV = EVENTS;
+  statMethods = { lstat: lstat2, stat: stat2 };
+  HANDLER_KEYS = [KEY_LISTENERS, KEY_ERR, KEY_RAW];
+  binaryExtensions = new Set([
+    "3dm",
+    "3ds",
+    "3g2",
+    "3gp",
+    "7z",
+    "a",
+    "aac",
+    "adp",
+    "afdesign",
+    "afphoto",
+    "afpub",
+    "ai",
+    "aif",
+    "aiff",
+    "alz",
+    "ape",
+    "apk",
+    "appimage",
+    "ar",
+    "arj",
+    "asf",
+    "au",
+    "avi",
+    "bak",
+    "baml",
+    "bh",
+    "bin",
+    "bk",
+    "bmp",
+    "btif",
+    "bz2",
+    "bzip2",
+    "cab",
+    "caf",
+    "cgm",
+    "class",
+    "cmx",
+    "cpio",
+    "cr2",
+    "cur",
+    "dat",
+    "dcm",
+    "deb",
+    "dex",
+    "djvu",
+    "dll",
+    "dmg",
+    "dng",
+    "doc",
+    "docm",
+    "docx",
+    "dot",
+    "dotm",
+    "dra",
+    "DS_Store",
+    "dsk",
+    "dts",
+    "dtshd",
+    "dvb",
+    "dwg",
+    "dxf",
+    "ecelp4800",
+    "ecelp7470",
+    "ecelp9600",
+    "egg",
+    "eol",
+    "eot",
+    "epub",
+    "exe",
+    "f4v",
+    "fbs",
+    "fh",
+    "fla",
+    "flac",
+    "flatpak",
+    "fli",
+    "flv",
+    "fpx",
+    "fst",
+    "fvt",
+    "g3",
+    "gh",
+    "gif",
+    "graffle",
+    "gz",
+    "gzip",
+    "h261",
+    "h263",
+    "h264",
+    "icns",
+    "ico",
+    "ief",
+    "img",
+    "ipa",
+    "iso",
+    "jar",
+    "jpeg",
+    "jpg",
+    "jpgv",
+    "jpm",
+    "jxr",
+    "key",
+    "ktx",
+    "lha",
+    "lib",
+    "lvp",
+    "lz",
+    "lzh",
+    "lzma",
+    "lzo",
+    "m3u",
+    "m4a",
+    "m4v",
+    "mar",
+    "mdi",
+    "mht",
+    "mid",
+    "midi",
+    "mj2",
+    "mka",
+    "mkv",
+    "mmr",
+    "mng",
+    "mobi",
+    "mov",
+    "movie",
+    "mp3",
+    "mp4",
+    "mp4a",
+    "mpeg",
+    "mpg",
+    "mpga",
+    "mxu",
+    "nef",
+    "npx",
+    "numbers",
+    "nupkg",
+    "o",
+    "odp",
+    "ods",
+    "odt",
+    "oga",
+    "ogg",
+    "ogv",
+    "otf",
+    "ott",
+    "pages",
+    "pbm",
+    "pcx",
+    "pdb",
+    "pdf",
+    "pea",
+    "pgm",
+    "pic",
+    "png",
+    "pnm",
+    "pot",
+    "potm",
+    "potx",
+    "ppa",
+    "ppam",
+    "ppm",
+    "pps",
+    "ppsm",
+    "ppsx",
+    "ppt",
+    "pptm",
+    "pptx",
+    "psd",
+    "pya",
+    "pyc",
+    "pyo",
+    "pyv",
+    "qt",
+    "rar",
+    "ras",
+    "raw",
+    "resources",
+    "rgb",
+    "rip",
+    "rlc",
+    "rmf",
+    "rmvb",
+    "rpm",
+    "rtf",
+    "rz",
+    "s3m",
+    "s7z",
+    "scpt",
+    "sgi",
+    "shar",
+    "snap",
+    "sil",
+    "sketch",
+    "slk",
+    "smv",
+    "snk",
+    "so",
+    "stl",
+    "suo",
+    "sub",
+    "swf",
+    "tar",
+    "tbz",
+    "tbz2",
+    "tga",
+    "tgz",
+    "thmx",
+    "tif",
+    "tiff",
+    "tlz",
+    "ttc",
+    "ttf",
+    "txz",
+    "udf",
+    "uvh",
+    "uvi",
+    "uvm",
+    "uvp",
+    "uvs",
+    "uvu",
+    "viv",
+    "vob",
+    "war",
+    "wav",
+    "wax",
+    "wbmp",
+    "wdp",
+    "weba",
+    "webm",
+    "webp",
+    "whl",
+    "wim",
+    "wm",
+    "wma",
+    "wmv",
+    "wmx",
+    "woff",
+    "woff2",
+    "wrm",
+    "wvx",
+    "xbm",
+    "xif",
+    "xla",
+    "xlam",
+    "xls",
+    "xlsb",
+    "xlsm",
+    "xlsx",
+    "xlt",
+    "xltm",
+    "xltx",
+    "xm",
+    "xmind",
+    "xpi",
+    "xpm",
+    "xwd",
+    "xz",
+    "z",
+    "zip",
+    "zipx"
+  ]);
+  FsWatchInstances = new Map;
+  FsWatchFileInstances = new Map;
+});
+
+// node_modules/chokidar/esm/index.js
+import { stat as statcb } from "fs";
+import { stat as stat3, readdir as readdir2 } from "fs/promises";
+import { EventEmitter as EventEmitter2 } from "events";
+import * as sysPath2 from "path";
+function arrify(item) {
+  return Array.isArray(item) ? item : [item];
+}
+function createPattern(matcher) {
+  if (typeof matcher === "function")
+    return matcher;
+  if (typeof matcher === "string")
+    return (string) => matcher === string;
+  if (matcher instanceof RegExp)
+    return (string) => matcher.test(string);
+  if (typeof matcher === "object" && matcher !== null) {
+    return (string) => {
+      if (matcher.path === string)
+        return true;
+      if (matcher.recursive) {
+        const relative5 = sysPath2.relative(matcher.path, string);
+        if (!relative5) {
+          return false;
+        }
+        return !relative5.startsWith("..") && !sysPath2.isAbsolute(relative5);
+      }
+      return false;
+    };
+  }
+  return () => false;
+}
+function normalizePath(path) {
+  if (typeof path !== "string")
+    throw new Error("string expected");
+  path = sysPath2.normalize(path);
+  path = path.replace(/\\/g, "/");
+  let prepend = false;
+  if (path.startsWith("//"))
+    prepend = true;
+  const DOUBLE_SLASH_RE2 = /\/\//;
+  while (path.match(DOUBLE_SLASH_RE2))
+    path = path.replace(DOUBLE_SLASH_RE2, "/");
+  if (prepend)
+    path = "/" + path;
+  return path;
+}
+function matchPatterns(patterns, testString, stats) {
+  const path = normalizePath(testString);
+  for (let index = 0;index < patterns.length; index++) {
+    const pattern = patterns[index];
+    if (pattern(path, stats)) {
+      return true;
+    }
+  }
+  return false;
+}
+function anymatch(matchers, testString) {
+  if (matchers == null) {
+    throw new TypeError("anymatch: specify first argument");
+  }
+  const matchersArray = arrify(matchers);
+  const patterns = matchersArray.map((matcher) => createPattern(matcher));
+  if (testString == null) {
+    return (testString2, stats) => {
+      return matchPatterns(patterns, testString2, stats);
+    };
+  }
+  return matchPatterns(patterns, testString);
+}
+
+class DirEntry {
+  constructor(dir, removeWatcher) {
+    this.path = dir;
+    this._removeWatcher = removeWatcher;
+    this.items = new Set;
+  }
+  add(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    if (item !== ONE_DOT && item !== TWO_DOTS)
+      items.add(item);
+  }
+  async remove(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    items.delete(item);
+    if (items.size > 0)
+      return;
+    const dir = this.path;
+    try {
+      await readdir2(dir);
+    } catch (err) {
+      if (this._removeWatcher) {
+        this._removeWatcher(sysPath2.dirname(dir), sysPath2.basename(dir));
+      }
+    }
+  }
+  has(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    return items.has(item);
+  }
+  getChildren() {
+    const { items } = this;
+    if (!items)
+      return [];
+    return [...items.values()];
+  }
+  dispose() {
+    this.items.clear();
+    this.path = "";
+    this._removeWatcher = EMPTY_FN;
+    this.items = EMPTY_SET;
+    Object.freeze(this);
+  }
+}
+
+class WatchHelper {
+  constructor(path, follow, fsw) {
+    this.fsw = fsw;
+    const watchPath = path;
+    this.path = path = path.replace(REPLACER_RE, "");
+    this.watchPath = watchPath;
+    this.fullWatchPath = sysPath2.resolve(watchPath);
+    this.dirParts = [];
+    this.dirParts.forEach((parts) => {
+      if (parts.length > 1)
+        parts.pop();
+    });
+    this.followSymlinks = follow;
+    this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
+  }
+  entryPath(entry) {
+    return sysPath2.join(this.watchPath, sysPath2.relative(this.watchPath, entry.fullPath));
+  }
+  filterPath(entry) {
+    const { stats } = entry;
+    if (stats && stats.isSymbolicLink())
+      return this.filterDir(entry);
+    const resolvedPath = this.entryPath(entry);
+    return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
+  }
+  filterDir(entry) {
+    return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
+  }
+}
+function watch(paths, options = {}) {
+  const watcher = new FSWatcher(options);
+  watcher.add(paths);
+  return watcher;
+}
+var SLASH = "/", SLASH_SLASH = "//", ONE_DOT = ".", TWO_DOTS = "..", STRING_TYPE = "string", BACK_SLASH_RE, DOUBLE_SLASH_RE, DOT_RE, REPLACER_RE, isMatcherObject = (matcher) => typeof matcher === "object" && matcher !== null && !(matcher instanceof RegExp), unifyPaths = (paths_) => {
+  const paths = arrify(paths_).flat();
+  if (!paths.every((p2) => typeof p2 === STRING_TYPE)) {
+    throw new TypeError(`Non-string provided as watch path: ${paths}`);
+  }
+  return paths.map(normalizePathToUnix);
+}, toUnix = (string) => {
+  let str = string.replace(BACK_SLASH_RE, SLASH);
+  let prepend = false;
+  if (str.startsWith(SLASH_SLASH)) {
+    prepend = true;
+  }
+  while (str.match(DOUBLE_SLASH_RE)) {
+    str = str.replace(DOUBLE_SLASH_RE, SLASH);
+  }
+  if (prepend) {
+    str = SLASH + str;
+  }
+  return str;
+}, normalizePathToUnix = (path) => toUnix(sysPath2.normalize(toUnix(path))), normalizeIgnored = (cwd = "") => (path) => {
+  if (typeof path === "string") {
+    return normalizePathToUnix(sysPath2.isAbsolute(path) ? path : sysPath2.join(cwd, path));
+  } else {
+    return path;
+  }
+}, getAbsolutePath = (path, cwd) => {
+  if (sysPath2.isAbsolute(path)) {
+    return path;
+  }
+  return sysPath2.join(cwd, path);
+}, EMPTY_SET, STAT_METHOD_F = "stat", STAT_METHOD_L = "lstat", FSWatcher, esm_default2;
+var init_esm3 = __esm(() => {
+  init_esm2();
+  init_handler();
+  /*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */
+  BACK_SLASH_RE = /\\/g;
+  DOUBLE_SLASH_RE = /\/\//;
+  DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
+  REPLACER_RE = /^\.[/\\]/;
+  EMPTY_SET = Object.freeze(new Set);
+  FSWatcher = class FSWatcher extends EventEmitter2 {
+    constructor(_opts = {}) {
+      super();
+      this.closed = false;
+      this._closers = new Map;
+      this._ignoredPaths = new Set;
+      this._throttled = new Map;
+      this._streams = new Set;
+      this._symlinkPaths = new Map;
+      this._watched = new Map;
+      this._pendingWrites = new Map;
+      this._pendingUnlinks = new Map;
+      this._readyCount = 0;
+      this._readyEmitted = false;
+      const awf = _opts.awaitWriteFinish;
+      const DEF_AWF = { stabilityThreshold: 2000, pollInterval: 100 };
+      const opts = {
+        persistent: true,
+        ignoreInitial: false,
+        ignorePermissionErrors: false,
+        interval: 100,
+        binaryInterval: 300,
+        followSymlinks: true,
+        usePolling: false,
+        atomic: true,
+        ..._opts,
+        ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]),
+        awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === "object" ? { ...DEF_AWF, ...awf } : false
+      };
+      if (isIBMi)
+        opts.usePolling = true;
+      if (opts.atomic === undefined)
+        opts.atomic = !opts.usePolling;
+      const envPoll = process.env.CHOKIDAR_USEPOLLING;
+      if (envPoll !== undefined) {
+        const envLower = envPoll.toLowerCase();
+        if (envLower === "false" || envLower === "0")
+          opts.usePolling = false;
+        else if (envLower === "true" || envLower === "1")
+          opts.usePolling = true;
+        else
+          opts.usePolling = !!envLower;
+      }
+      const envInterval = process.env.CHOKIDAR_INTERVAL;
+      if (envInterval)
+        opts.interval = Number.parseInt(envInterval, 10);
+      let readyCalls = 0;
+      this._emitReady = () => {
+        readyCalls++;
+        if (readyCalls >= this._readyCount) {
+          this._emitReady = EMPTY_FN;
+          this._readyEmitted = true;
+          process.nextTick(() => this.emit(EVENTS.READY));
+        }
+      };
+      this._emitRaw = (...args) => this.emit(EVENTS.RAW, ...args);
+      this._boundRemove = this._remove.bind(this);
+      this.options = opts;
+      this._nodeFsHandler = new NodeFsHandler(this);
+      Object.freeze(opts);
+    }
+    _addIgnoredPath(matcher) {
+      if (isMatcherObject(matcher)) {
+        for (const ignored of this._ignoredPaths) {
+          if (isMatcherObject(ignored) && ignored.path === matcher.path && ignored.recursive === matcher.recursive) {
+            return;
+          }
+        }
+      }
+      this._ignoredPaths.add(matcher);
+    }
+    _removeIgnoredPath(matcher) {
+      this._ignoredPaths.delete(matcher);
+      if (typeof matcher === "string") {
+        for (const ignored of this._ignoredPaths) {
+          if (isMatcherObject(ignored) && ignored.path === matcher) {
+            this._ignoredPaths.delete(ignored);
+          }
+        }
+      }
+    }
+    add(paths_, _origAdd, _internal) {
+      const { cwd } = this.options;
+      this.closed = false;
+      this._closePromise = undefined;
+      let paths = unifyPaths(paths_);
+      if (cwd) {
+        paths = paths.map((path) => {
+          const absPath = getAbsolutePath(path, cwd);
+          return absPath;
+        });
+      }
+      paths.forEach((path) => {
+        this._removeIgnoredPath(path);
+      });
+      this._userIgnored = undefined;
+      if (!this._readyCount)
+        this._readyCount = 0;
+      this._readyCount += paths.length;
+      Promise.all(paths.map(async (path) => {
+        const res = await this._nodeFsHandler._addToNodeFs(path, !_internal, undefined, 0, _origAdd);
+        if (res)
+          this._emitReady();
+        return res;
+      })).then((results) => {
+        if (this.closed)
+          return;
+        results.forEach((item) => {
+          if (item)
+            this.add(sysPath2.dirname(item), sysPath2.basename(_origAdd || item));
+        });
+      });
+      return this;
+    }
+    unwatch(paths_) {
+      if (this.closed)
+        return this;
+      const paths = unifyPaths(paths_);
+      const { cwd } = this.options;
+      paths.forEach((path) => {
+        if (!sysPath2.isAbsolute(path) && !this._closers.has(path)) {
+          if (cwd)
+            path = sysPath2.join(cwd, path);
+          path = sysPath2.resolve(path);
+        }
+        this._closePath(path);
+        this._addIgnoredPath(path);
+        if (this._watched.has(path)) {
+          this._addIgnoredPath({
+            path,
+            recursive: true
+          });
+        }
+        this._userIgnored = undefined;
+      });
+      return this;
+    }
+    close() {
+      if (this._closePromise) {
+        return this._closePromise;
+      }
+      this.closed = true;
+      this.removeAllListeners();
+      const closers = [];
+      this._closers.forEach((closerList) => closerList.forEach((closer) => {
+        const promise = closer();
+        if (promise instanceof Promise)
+          closers.push(promise);
+      }));
+      this._streams.forEach((stream) => stream.destroy());
+      this._userIgnored = undefined;
+      this._readyCount = 0;
+      this._readyEmitted = false;
+      this._watched.forEach((dirent) => dirent.dispose());
+      this._closers.clear();
+      this._watched.clear();
+      this._streams.clear();
+      this._symlinkPaths.clear();
+      this._throttled.clear();
+      this._closePromise = closers.length ? Promise.all(closers).then(() => {
+        return;
+      }) : Promise.resolve();
+      return this._closePromise;
+    }
+    getWatched() {
+      const watchList = {};
+      this._watched.forEach((entry, dir) => {
+        const key = this.options.cwd ? sysPath2.relative(this.options.cwd, dir) : dir;
+        const index = key || ONE_DOT;
+        watchList[index] = entry.getChildren().sort();
+      });
+      return watchList;
+    }
+    emitWithAll(event, args) {
+      this.emit(event, ...args);
+      if (event !== EVENTS.ERROR)
+        this.emit(EVENTS.ALL, event, ...args);
+    }
+    async _emit(event, path, stats) {
+      if (this.closed)
+        return;
+      const opts = this.options;
+      if (isWindows)
+        path = sysPath2.normalize(path);
+      if (opts.cwd)
+        path = sysPath2.relative(opts.cwd, path);
+      const args = [path];
+      if (stats != null)
+        args.push(stats);
+      const awf = opts.awaitWriteFinish;
+      let pw;
+      if (awf && (pw = this._pendingWrites.get(path))) {
+        pw.lastChange = new Date;
+        return this;
+      }
+      if (opts.atomic) {
+        if (event === EVENTS.UNLINK) {
+          this._pendingUnlinks.set(path, [event, ...args]);
+          setTimeout(() => {
+            this._pendingUnlinks.forEach((entry, path2) => {
+              this.emit(...entry);
+              this.emit(EVENTS.ALL, ...entry);
+              this._pendingUnlinks.delete(path2);
+            });
+          }, typeof opts.atomic === "number" ? opts.atomic : 100);
+          return this;
+        }
+        if (event === EVENTS.ADD && this._pendingUnlinks.has(path)) {
+          event = EVENTS.CHANGE;
+          this._pendingUnlinks.delete(path);
+        }
+      }
+      if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
+        const awfEmit = (err, stats2) => {
+          if (err) {
+            event = EVENTS.ERROR;
+            args[0] = err;
+            this.emitWithAll(event, args);
+          } else if (stats2) {
+            if (args.length > 1) {
+              args[1] = stats2;
+            } else {
+              args.push(stats2);
+            }
+            this.emitWithAll(event, args);
+          }
+        };
+        this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit);
+        return this;
+      }
+      if (event === EVENTS.CHANGE) {
+        const isThrottled = !this._throttle(EVENTS.CHANGE, path, 50);
+        if (isThrottled)
+          return this;
+      }
+      if (opts.alwaysStat && stats === undefined && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
+        const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path) : path;
+        let stats2;
+        try {
+          stats2 = await stat3(fullPath);
+        } catch (err) {}
+        if (!stats2 || this.closed)
+          return;
+        args.push(stats2);
+      }
+      this.emitWithAll(event, args);
+      return this;
+    }
+    _handleError(error) {
+      const code = error && error.code;
+      if (error && code !== "ENOENT" && code !== "ENOTDIR" && (!this.options.ignorePermissionErrors || code !== "EPERM" && code !== "EACCES")) {
+        this.emit(EVENTS.ERROR, error);
+      }
+      return error || this.closed;
+    }
+    _throttle(actionType, path, timeout) {
+      if (!this._throttled.has(actionType)) {
+        this._throttled.set(actionType, new Map);
+      }
+      const action = this._throttled.get(actionType);
+      if (!action)
+        throw new Error("invalid throttle");
+      const actionPath = action.get(path);
+      if (actionPath) {
+        actionPath.count++;
+        return false;
+      }
+      let timeoutObject;
+      const clear = () => {
+        const item = action.get(path);
+        const count = item ? item.count : 0;
+        action.delete(path);
+        clearTimeout(timeoutObject);
+        if (item)
+          clearTimeout(item.timeoutObject);
+        return count;
+      };
+      timeoutObject = setTimeout(clear, timeout);
+      const thr = { timeoutObject, clear, count: 0 };
+      action.set(path, thr);
+      return thr;
+    }
+    _incrReadyCount() {
+      return this._readyCount++;
+    }
+    _awaitWriteFinish(path, threshold, event, awfEmit) {
+      const awf = this.options.awaitWriteFinish;
+      if (typeof awf !== "object")
+        return;
+      const pollInterval = awf.pollInterval;
+      let timeoutHandler;
+      let fullPath = path;
+      if (this.options.cwd && !sysPath2.isAbsolute(path)) {
+        fullPath = sysPath2.join(this.options.cwd, path);
+      }
+      const now = new Date;
+      const writes = this._pendingWrites;
+      function awaitWriteFinishFn(prevStat) {
+        statcb(fullPath, (err, curStat) => {
+          if (err || !writes.has(path)) {
+            if (err && err.code !== "ENOENT")
+              awfEmit(err);
+            return;
+          }
+          const now2 = Number(new Date);
+          if (prevStat && curStat.size !== prevStat.size) {
+            writes.get(path).lastChange = now2;
+          }
+          const pw = writes.get(path);
+          const df = now2 - pw.lastChange;
+          if (df >= threshold) {
+            writes.delete(path);
+            awfEmit(undefined, curStat);
+          } else {
+            timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
+          }
+        });
+      }
+      if (!writes.has(path)) {
+        writes.set(path, {
+          lastChange: now,
+          cancelWait: () => {
+            writes.delete(path);
+            clearTimeout(timeoutHandler);
+            return event;
+          }
+        });
+        timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
+      }
+    }
+    _isIgnored(path, stats) {
+      if (this.options.atomic && DOT_RE.test(path))
+        return true;
+      if (!this._userIgnored) {
+        const { cwd } = this.options;
+        const ign = this.options.ignored;
+        const ignored = (ign || []).map(normalizeIgnored(cwd));
+        const ignoredPaths = [...this._ignoredPaths];
+        const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
+        this._userIgnored = anymatch(list, undefined);
+      }
+      return this._userIgnored(path, stats);
+    }
+    _isntIgnored(path, stat4) {
+      return !this._isIgnored(path, stat4);
+    }
+    _getWatchHelpers(path) {
+      return new WatchHelper(path, this.options.followSymlinks, this);
+    }
+    _getWatchedDir(directory) {
+      const dir = sysPath2.resolve(directory);
+      if (!this._watched.has(dir))
+        this._watched.set(dir, new DirEntry(dir, this._boundRemove));
+      return this._watched.get(dir);
+    }
+    _hasReadPermissions(stats) {
+      if (this.options.ignorePermissionErrors)
+        return true;
+      return Boolean(Number(stats.mode) & 256);
+    }
+    _remove(directory, item, isDirectory) {
+      const path = sysPath2.join(directory, item);
+      const fullPath = sysPath2.resolve(path);
+      isDirectory = isDirectory != null ? isDirectory : this._watched.has(path) || this._watched.has(fullPath);
+      if (!this._throttle("remove", path, 100))
+        return;
+      if (!isDirectory && this._watched.size === 1) {
+        this.add(directory, item, true);
+      }
+      const wp = this._getWatchedDir(path);
+      const nestedDirectoryChildren = wp.getChildren();
+      nestedDirectoryChildren.forEach((nested) => this._remove(path, nested));
+      const parent = this._getWatchedDir(directory);
+      const wasTracked = parent.has(item);
+      parent.remove(item);
+      if (this._symlinkPaths.has(fullPath)) {
+        this._symlinkPaths.delete(fullPath);
+      }
+      let relPath = path;
+      if (this.options.cwd)
+        relPath = sysPath2.relative(this.options.cwd, path);
+      if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
+        const event = this._pendingWrites.get(relPath).cancelWait();
+        if (event === EVENTS.ADD)
+          return;
+      }
+      this._watched.delete(path);
+      this._watched.delete(fullPath);
+      const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
+      if (wasTracked && !this._isIgnored(path))
+        this._emit(eventName, path);
+      this._closePath(path);
+    }
+    _closePath(path) {
+      this._closeFile(path);
+      const dir = sysPath2.dirname(path);
+      this._getWatchedDir(dir).remove(sysPath2.basename(path));
+    }
+    _closeFile(path) {
+      const closers = this._closers.get(path);
+      if (!closers)
+        return;
+      closers.forEach((closer) => closer());
+      this._closers.delete(path);
+    }
+    _addPathCloser(path, closer) {
+      if (!closer)
+        return;
+      let list = this._closers.get(path);
+      if (!list) {
+        list = [];
+        this._closers.set(path, list);
+      }
+      list.push(closer);
+    }
+    _readdirp(root, opts) {
+      if (this.closed)
+        return;
+      const options = { type: EVENTS.ALL, alwaysStat: true, lstat: true, ...opts, depth: 0 };
+      let stream = readdirp(root, options);
+      this._streams.add(stream);
+      stream.once(STR_CLOSE, () => {
+        stream = undefined;
+      });
+      stream.once(STR_END, () => {
+        if (stream) {
+          this._streams.delete(stream);
+          stream = undefined;
+        }
+      });
+      return stream;
+    }
+  };
+  esm_default2 = { watch, FSWatcher };
+});
+
+// src/lib/watcher.ts
+var exports_watcher = {};
+__export(exports_watcher, {
+  watchSource: () => watchSource,
+  unwatchSource: () => unwatchSource,
+  stopAllWatchers: () => stopAllWatchers
+});
+import { extname as extname6, basename as basename6, relative as relative5 } from "path";
+import { statSync as statSync3 } from "fs";
+function watchSource(source, machine_id) {
+  if (!source.path)
+    return;
+  if (watchers.has(source.id))
+    return;
+  const watcher = esm_default2.watch(source.path, {
+    ignored: IGNORE_PATTERNS,
+    persistent: true,
+    ignoreInitial: true,
+    awaitWriteFinish: { stabilityThreshold: 500, pollInterval: 100 }
+  });
+  watcher.on("add", (fullPath) => handleAdd(fullPath, source, machine_id));
+  watcher.on("change", (fullPath) => handleAdd(fullPath, source, machine_id));
+  watcher.on("unlink", (fullPath) => {
+    const relPath = relative5(source.path, fullPath);
+    markFileDeleted(source.id, relPath);
+  });
+  watchers.set(source.id, watcher);
+}
+function unwatchSource(source_id) {
+  const w2 = watchers.get(source_id);
+  if (w2) {
+    w2.close();
+    watchers.delete(source_id);
+  }
+}
+function stopAllWatchers() {
+  for (const [id] of watchers)
+    unwatchSource(id);
+}
+function handleAdd(fullPath, source, machine_id) {
+  try {
+    const stat4 = statSync3(fullPath);
+    if (!stat4.isFile())
+      return;
+    const relPath = relative5(source.path, fullPath);
+    const entry = basename6(fullPath);
+    const hash = hashFile(fullPath);
+    upsertFile({
+      source_id: source.id,
+      machine_id,
+      path: relPath,
+      name: entry,
+      ext: extname6(entry).toLowerCase(),
+      size: stat4.size,
+      mime: $lookup(entry) || "application/octet-stream",
+      hash,
+      status: "active",
+      modified_at: stat4.mtime.toISOString()
+    });
+  } catch {}
+}
+var IGNORE_PATTERNS, watchers;
+var init_watcher = __esm(() => {
+  init_esm3();
+  init_mime_types();
+  init_hasher();
+  init_files();
+  IGNORE_PATTERNS = [
+    /node_modules/,
+    /\.git/,
+    /\.DS_Store/,
+    /__pycache__/,
+    /\.next/,
+    /\/dist\//
+  ];
+  watchers = new Map;
+});
+
 // src/mcp/index.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -58620,6 +61812,9 @@ function getOrCreateTag(name, color) {
   db.run("INSERT INTO tags (id, name, color) VALUES (?, ?, ?)", [id, name.toLowerCase(), color ?? "#6366f1"]);
   return db.query("SELECT * FROM tags WHERE id = ?").get(id);
 }
+function deleteTag(id) {
+  return getDb().run("DELETE FROM tags WHERE id = ?", [id]).changes > 0;
+}
 function tagFile(file_id, tag_name) {
   const tag = getOrCreateTag(tag_name);
   const db = getDb();
@@ -58685,6 +61880,9 @@ function getCollection(id) {
   const children = db.query("SELECT * FROM collections WHERE parent_id=? ORDER BY name").all(id).map(toCollection);
   return { ...toCollection(row), file_count, children };
 }
+function deleteCollection(id) {
+  return getDb().run("DELETE FROM collections WHERE id=?", [id]).changes > 0;
+}
 function addToCollection(collection_id, file_id) {
   getDb().run("INSERT OR IGNORE INTO collection_files (collection_id, file_id) VALUES (?,?)", [collection_id, file_id]);
 }
@@ -58772,6 +61970,9 @@ function getProject(id) {
   const file_count = db.query("SELECT COUNT(*) as cnt FROM project_files WHERE project_id=?").get(id).cnt;
   return { ...toProject(row), file_count };
 }
+function deleteProject(id) {
+  return getDb().run("DELETE FROM projects WHERE id=?", [id]).changes > 0;
+}
 function addToProject(project_id, file_id) {
   getDb().run("INSERT OR IGNORE INTO project_files (project_id, file_id) VALUES (?,?)", [project_id, file_id]);
 }
@@ -58781,440 +61982,10 @@ function removeFromProject(project_id, file_id) {
 
 // src/lib/indexer.ts
 init_mime_types();
+init_hasher();
 import { readdirSync as readdirSync3, statSync, existsSync as existsSync7 } from "fs";
 import { join as join8, relative as relative2, extname as extname3, basename as basename2 } from "path";
 
-// node_modules/@noble/hashes/esm/utils.js
-/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-function isBytes(a) {
-  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
-}
-function anumber(n) {
-  if (!Number.isSafeInteger(n) || n < 0)
-    throw new Error("positive integer expected, got " + n);
-}
-function abytes(b, ...lengths) {
-  if (!isBytes(b))
-    throw new Error("Uint8Array expected");
-  if (lengths.length > 0 && !lengths.includes(b.length))
-    throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
-}
-function aexists(instance, checkFinished = true) {
-  if (instance.destroyed)
-    throw new Error("Hash instance has been destroyed");
-  if (checkFinished && instance.finished)
-    throw new Error("Hash#digest() has already been called");
-}
-function aoutput(out, instance) {
-  abytes(out);
-  const min = instance.outputLen;
-  if (out.length < min) {
-    throw new Error("digestInto() expects output buffer of length at least " + min);
-  }
-}
-function u8(arr) {
-  return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
-}
-function u32(arr) {
-  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
-}
-function clean(...arrays) {
-  for (let i = 0;i < arrays.length; i++) {
-    arrays[i].fill(0);
-  }
-}
-function rotr(word, shift) {
-  return word << 32 - shift | word >>> shift;
-}
-var isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
-function byteSwap(word) {
-  return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
-}
-var swap8IfBE = isLE ? (n) => n : (n) => byteSwap(n);
-function byteSwap32(arr) {
-  for (let i = 0;i < arr.length; i++) {
-    arr[i] = byteSwap(arr[i]);
-  }
-  return arr;
-}
-var swap32IfBE = isLE ? (u) => u : byteSwap32;
-function utf8ToBytes(str) {
-  if (typeof str !== "string")
-    throw new Error("string expected");
-  return new Uint8Array(new TextEncoder().encode(str));
-}
-function toBytes(data) {
-  if (typeof data === "string")
-    data = utf8ToBytes(data);
-  abytes(data);
-  return data;
-}
-class Hash {
-}
-function createXOFer(hashCons) {
-  const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
-  const tmp = hashCons({});
-  hashC.outputLen = tmp.outputLen;
-  hashC.blockLen = tmp.blockLen;
-  hashC.create = (opts) => hashCons(opts);
-  return hashC;
-}
-
-// node_modules/@noble/hashes/esm/_md.js
-var SHA256_IV = /* @__PURE__ */ Uint32Array.from([
-  1779033703,
-  3144134277,
-  1013904242,
-  2773480762,
-  1359893119,
-  2600822924,
-  528734635,
-  1541459225
-]);
-
-// node_modules/@noble/hashes/esm/_u64.js
-var U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
-var _32n = /* @__PURE__ */ BigInt(32);
-function fromBig(n, le = false) {
-  if (le)
-    return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
-  return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
-}
-
-// node_modules/@noble/hashes/esm/_blake.js
-function G1s(a, b, c, d, x) {
-  a = a + b + x | 0;
-  d = rotr(d ^ a, 16);
-  c = c + d | 0;
-  b = rotr(b ^ c, 12);
-  return { a, b, c, d };
-}
-function G2s(a, b, c, d, x) {
-  a = a + b + x | 0;
-  d = rotr(d ^ a, 8);
-  c = c + d | 0;
-  b = rotr(b ^ c, 7);
-  return { a, b, c, d };
-}
-
-// node_modules/@noble/hashes/esm/blake2.js
-class BLAKE2 extends Hash {
-  constructor(blockLen, outputLen) {
-    super();
-    this.finished = false;
-    this.destroyed = false;
-    this.length = 0;
-    this.pos = 0;
-    anumber(blockLen);
-    anumber(outputLen);
-    this.blockLen = blockLen;
-    this.outputLen = outputLen;
-    this.buffer = new Uint8Array(blockLen);
-    this.buffer32 = u32(this.buffer);
-  }
-  update(data) {
-    aexists(this);
-    data = toBytes(data);
-    abytes(data);
-    const { blockLen, buffer, buffer32 } = this;
-    const len = data.length;
-    const offset = data.byteOffset;
-    const buf = data.buffer;
-    for (let pos = 0;pos < len; ) {
-      if (this.pos === blockLen) {
-        swap32IfBE(buffer32);
-        this.compress(buffer32, 0, false);
-        swap32IfBE(buffer32);
-        this.pos = 0;
-      }
-      const take = Math.min(blockLen - this.pos, len - pos);
-      const dataOffset = offset + pos;
-      if (take === blockLen && !(dataOffset % 4) && pos + take < len) {
-        const data32 = new Uint32Array(buf, dataOffset, Math.floor((len - pos) / 4));
-        swap32IfBE(data32);
-        for (let pos32 = 0;pos + blockLen < len; pos32 += buffer32.length, pos += blockLen) {
-          this.length += blockLen;
-          this.compress(data32, pos32, false);
-        }
-        swap32IfBE(data32);
-        continue;
-      }
-      buffer.set(data.subarray(pos, pos + take), this.pos);
-      this.pos += take;
-      this.length += take;
-      pos += take;
-    }
-    return this;
-  }
-  digestInto(out) {
-    aexists(this);
-    aoutput(out, this);
-    const { pos, buffer32 } = this;
-    this.finished = true;
-    clean(this.buffer.subarray(pos));
-    swap32IfBE(buffer32);
-    this.compress(buffer32, 0, true);
-    swap32IfBE(buffer32);
-    const out32 = u32(out);
-    this.get().forEach((v, i) => out32[i] = swap8IfBE(v));
-  }
-  digest() {
-    const { buffer, outputLen } = this;
-    this.digestInto(buffer);
-    const res = buffer.slice(0, outputLen);
-    this.destroy();
-    return res;
-  }
-  _cloneInto(to) {
-    const { buffer, length, finished, destroyed, outputLen, pos } = this;
-    to || (to = new this.constructor({ dkLen: outputLen }));
-    to.set(...this.get());
-    to.buffer.set(buffer);
-    to.destroyed = destroyed;
-    to.finished = finished;
-    to.length = length;
-    to.pos = pos;
-    to.outputLen = outputLen;
-    return to;
-  }
-  clone() {
-    return this._cloneInto();
-  }
-}
-function compress(s, offset, msg, rounds, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) {
-  let j = 0;
-  for (let i = 0;i < rounds; i++) {
-    ({ a: v0, b: v4, c: v8, d: v12 } = G1s(v0, v4, v8, v12, msg[offset + s[j++]]));
-    ({ a: v0, b: v4, c: v8, d: v12 } = G2s(v0, v4, v8, v12, msg[offset + s[j++]]));
-    ({ a: v1, b: v5, c: v9, d: v13 } = G1s(v1, v5, v9, v13, msg[offset + s[j++]]));
-    ({ a: v1, b: v5, c: v9, d: v13 } = G2s(v1, v5, v9, v13, msg[offset + s[j++]]));
-    ({ a: v2, b: v6, c: v10, d: v14 } = G1s(v2, v6, v10, v14, msg[offset + s[j++]]));
-    ({ a: v2, b: v6, c: v10, d: v14 } = G2s(v2, v6, v10, v14, msg[offset + s[j++]]));
-    ({ a: v3, b: v7, c: v11, d: v15 } = G1s(v3, v7, v11, v15, msg[offset + s[j++]]));
-    ({ a: v3, b: v7, c: v11, d: v15 } = G2s(v3, v7, v11, v15, msg[offset + s[j++]]));
-    ({ a: v0, b: v5, c: v10, d: v15 } = G1s(v0, v5, v10, v15, msg[offset + s[j++]]));
-    ({ a: v0, b: v5, c: v10, d: v15 } = G2s(v0, v5, v10, v15, msg[offset + s[j++]]));
-    ({ a: v1, b: v6, c: v11, d: v12 } = G1s(v1, v6, v11, v12, msg[offset + s[j++]]));
-    ({ a: v1, b: v6, c: v11, d: v12 } = G2s(v1, v6, v11, v12, msg[offset + s[j++]]));
-    ({ a: v2, b: v7, c: v8, d: v13 } = G1s(v2, v7, v8, v13, msg[offset + s[j++]]));
-    ({ a: v2, b: v7, c: v8, d: v13 } = G2s(v2, v7, v8, v13, msg[offset + s[j++]]));
-    ({ a: v3, b: v4, c: v9, d: v14 } = G1s(v3, v4, v9, v14, msg[offset + s[j++]]));
-    ({ a: v3, b: v4, c: v9, d: v14 } = G2s(v3, v4, v9, v14, msg[offset + s[j++]]));
-  }
-  return { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 };
-}
-
-// node_modules/@noble/hashes/esm/blake3.js
-var B3_Flags = {
-  CHUNK_START: 1,
-  CHUNK_END: 2,
-  PARENT: 4,
-  ROOT: 8,
-  KEYED_HASH: 16,
-  DERIVE_KEY_CONTEXT: 32,
-  DERIVE_KEY_MATERIAL: 64
-};
-var B3_IV = SHA256_IV.slice();
-var B3_SIGMA = /* @__PURE__ */ (() => {
-  const Id = Array.from({ length: 16 }, (_, i) => i);
-  const permute = (arr) => [2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8].map((i) => arr[i]);
-  const res = [];
-  for (let i = 0, v = Id;i < 7; i++, v = permute(v))
-    res.push(...v);
-  return Uint8Array.from(res);
-})();
-
-class BLAKE3 extends BLAKE2 {
-  constructor(opts = {}, flags = 0) {
-    super(64, opts.dkLen === undefined ? 32 : opts.dkLen);
-    this.chunkPos = 0;
-    this.chunksDone = 0;
-    this.flags = 0 | 0;
-    this.stack = [];
-    this.posOut = 0;
-    this.bufferOut32 = new Uint32Array(16);
-    this.chunkOut = 0;
-    this.enableXOF = true;
-    const { key, context } = opts;
-    const hasContext = context !== undefined;
-    if (key !== undefined) {
-      if (hasContext)
-        throw new Error('Only "key" or "context" can be specified at same time');
-      const k = toBytes(key).slice();
-      abytes(k, 32);
-      this.IV = u32(k);
-      swap32IfBE(this.IV);
-      this.flags = flags | B3_Flags.KEYED_HASH;
-    } else if (hasContext) {
-      const ctx = toBytes(context);
-      const contextKey = new BLAKE3({ dkLen: 32 }, B3_Flags.DERIVE_KEY_CONTEXT).update(ctx).digest();
-      this.IV = u32(contextKey);
-      swap32IfBE(this.IV);
-      this.flags = flags | B3_Flags.DERIVE_KEY_MATERIAL;
-    } else {
-      this.IV = B3_IV.slice();
-      this.flags = flags;
-    }
-    this.state = this.IV.slice();
-    this.bufferOut = u8(this.bufferOut32);
-  }
-  get() {
-    return [];
-  }
-  set() {}
-  b2Compress(counter, flags, buf, bufPos = 0) {
-    const { state: s, pos } = this;
-    const { h, l } = fromBig(BigInt(counter), true);
-    const { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 } = compress(B3_SIGMA, bufPos, buf, 7, s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], B3_IV[0], B3_IV[1], B3_IV[2], B3_IV[3], h, l, pos, flags);
-    s[0] = v0 ^ v8;
-    s[1] = v1 ^ v9;
-    s[2] = v2 ^ v10;
-    s[3] = v3 ^ v11;
-    s[4] = v4 ^ v12;
-    s[5] = v5 ^ v13;
-    s[6] = v6 ^ v14;
-    s[7] = v7 ^ v15;
-  }
-  compress(buf, bufPos = 0, isLast = false) {
-    let flags = this.flags;
-    if (!this.chunkPos)
-      flags |= B3_Flags.CHUNK_START;
-    if (this.chunkPos === 15 || isLast)
-      flags |= B3_Flags.CHUNK_END;
-    if (!isLast)
-      this.pos = this.blockLen;
-    this.b2Compress(this.chunksDone, flags, buf, bufPos);
-    this.chunkPos += 1;
-    if (this.chunkPos === 16 || isLast) {
-      let chunk = this.state;
-      this.state = this.IV.slice();
-      for (let last, chunks = this.chunksDone + 1;isLast || !(chunks & 1); chunks >>= 1) {
-        if (!(last = this.stack.pop()))
-          break;
-        this.buffer32.set(last, 0);
-        this.buffer32.set(chunk, 8);
-        this.pos = this.blockLen;
-        this.b2Compress(0, this.flags | B3_Flags.PARENT, this.buffer32, 0);
-        chunk = this.state;
-        this.state = this.IV.slice();
-      }
-      this.chunksDone++;
-      this.chunkPos = 0;
-      this.stack.push(chunk);
-    }
-    this.pos = 0;
-  }
-  _cloneInto(to) {
-    to = super._cloneInto(to);
-    const { IV, flags, state, chunkPos, posOut, chunkOut, stack, chunksDone } = this;
-    to.state.set(state.slice());
-    to.stack = stack.map((i) => Uint32Array.from(i));
-    to.IV.set(IV);
-    to.flags = flags;
-    to.chunkPos = chunkPos;
-    to.chunksDone = chunksDone;
-    to.posOut = posOut;
-    to.chunkOut = chunkOut;
-    to.enableXOF = this.enableXOF;
-    to.bufferOut32.set(this.bufferOut32);
-    return to;
-  }
-  destroy() {
-    this.destroyed = true;
-    clean(this.state, this.buffer32, this.IV, this.bufferOut32);
-    clean(...this.stack);
-  }
-  b2CompressOut() {
-    const { state: s, pos, flags, buffer32, bufferOut32: out32 } = this;
-    const { h, l } = fromBig(BigInt(this.chunkOut++));
-    swap32IfBE(buffer32);
-    const { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 } = compress(B3_SIGMA, 0, buffer32, 7, s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], B3_IV[0], B3_IV[1], B3_IV[2], B3_IV[3], l, h, pos, flags);
-    out32[0] = v0 ^ v8;
-    out32[1] = v1 ^ v9;
-    out32[2] = v2 ^ v10;
-    out32[3] = v3 ^ v11;
-    out32[4] = v4 ^ v12;
-    out32[5] = v5 ^ v13;
-    out32[6] = v6 ^ v14;
-    out32[7] = v7 ^ v15;
-    out32[8] = s[0] ^ v8;
-    out32[9] = s[1] ^ v9;
-    out32[10] = s[2] ^ v10;
-    out32[11] = s[3] ^ v11;
-    out32[12] = s[4] ^ v12;
-    out32[13] = s[5] ^ v13;
-    out32[14] = s[6] ^ v14;
-    out32[15] = s[7] ^ v15;
-    swap32IfBE(buffer32);
-    swap32IfBE(out32);
-    this.posOut = 0;
-  }
-  finish() {
-    if (this.finished)
-      return;
-    this.finished = true;
-    clean(this.buffer.subarray(this.pos));
-    let flags = this.flags | B3_Flags.ROOT;
-    if (this.stack.length) {
-      flags |= B3_Flags.PARENT;
-      swap32IfBE(this.buffer32);
-      this.compress(this.buffer32, 0, true);
-      swap32IfBE(this.buffer32);
-      this.chunksDone = 0;
-      this.pos = this.blockLen;
-    } else {
-      flags |= (!this.chunkPos ? B3_Flags.CHUNK_START : 0) | B3_Flags.CHUNK_END;
-    }
-    this.flags = flags;
-    this.b2CompressOut();
-  }
-  writeInto(out) {
-    aexists(this, false);
-    abytes(out);
-    this.finish();
-    const { blockLen, bufferOut } = this;
-    for (let pos = 0, len = out.length;pos < len; ) {
-      if (this.posOut >= blockLen)
-        this.b2CompressOut();
-      const take = Math.min(blockLen - this.posOut, len - pos);
-      out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
-      this.posOut += take;
-      pos += take;
-    }
-    return out;
-  }
-  xofInto(out) {
-    if (!this.enableXOF)
-      throw new Error("XOF is not possible after digest call");
-    return this.writeInto(out);
-  }
-  xof(bytes) {
-    anumber(bytes);
-    return this.xofInto(new Uint8Array(bytes));
-  }
-  digestInto(out) {
-    aoutput(out, this);
-    if (this.finished)
-      throw new Error("digest() was already called");
-    this.enableXOF = false;
-    this.writeInto(out);
-    this.destroy();
-    return out;
-  }
-  digest() {
-    return this.digestInto(new Uint8Array(this.outputLen));
-  }
-}
-var blake3 = /* @__PURE__ */ createXOFer((opts) => new BLAKE3(opts));
-
-// src/lib/hasher.ts
-import { readFileSync as readFileSync2 } from "fs";
-function hashFile(filePath) {
-  const data = readFileSync2(filePath);
-  const hash = blake3(data);
-  return Buffer.from(hash).toString("hex");
-}
-
 // src/lib/ignore.ts
 import { readFileSync as readFileSync3, existsSync as existsSync6 } from "fs";
 import { join as join7 } from "path";
@@ -59476,7 +62247,7 @@ function applyFilters(conditions, params, opts) {
 }
 
 // src/mcp/index.ts
-import { join as join10 } from "path";
+import { join as join12 } from "path";
 import { existsSync as existsSync8 } from "fs";
 import { homedir as homedir9 } from "os";
 var server = new McpServer({
@@ -59558,6 +62329,7 @@ server.tool("list_files", "List indexed files with optional filters. If agent_id
   sort_dir: exports_external2.enum(["asc", "desc"]).optional().default("desc"),
   limit: exports_external2.number().optional().default(50),
   offset: exports_external2.number().optional().default(0),
+  sync_status: exports_external2.enum(["local_only", "synced", "conflict"]).optional().describe("Filter by sync status"),
   agent_id: exports_external2.string().optional().describe("Agent ID \u2014 auto-applies focused project filter if set")
 }, async (opts) => {
   if (opts.agent_id && !opts.project_id) {
@@ -59604,12 +62376,12 @@ server.tool("download_file", "Download a file from S3 to a local path", {
   if (!source)
     return { content: [{ type: "text", text: "Source not found" }], isError: true };
   if (source.type === "local") {
-    const fullPath = join10(source.path, file.path);
+    const fullPath = join12(source.path, file.path);
     if (agent_id)
       logActivity({ agent_id, action: "read", file_id: id, metadata: { path: fullPath } });
     return { content: [{ type: "text", text: `Local file: ${fullPath}` }] };
   }
-  const outPath = dest ?? join10(homedir9(), "Downloads", file.name);
+  const outPath = dest ?? join12(homedir9(), "Downloads", file.name);
   await downloadFromS3(source, file.path, outPath);
   if (agent_id)
     logActivity({ agent_id, action: "download", file_id: id, metadata: { dest: outPath } });
@@ -59660,6 +62432,12 @@ server.tool("untag_file", "Remove tags from a file", {
     logActivity({ agent_id, action: "untag", file_id, metadata: { tags } });
   return { content: [{ type: "text", text: "Tags removed" }] };
 });
+server.tool("delete_tag", "Delete a tag entirely (removes from all files)", {
+  id: exports_external2.string().describe("Tag ID")
+}, async ({ id }) => {
+  const ok = deleteTag(id);
+  return { content: [{ type: "text", text: ok ? `Tag ${id} deleted` : `Tag not found: ${id}` }] };
+});
 server.tool("list_collections", "List all collections", {
   parent_id: exports_external2.string().optional().describe("Filter by parent collection ID")
 }, async ({ parent_id }) => {
@@ -59724,6 +62502,12 @@ server.tool("remove_from_collection", "Remove a file from a collection", {
   removeFromCollection(collection_id, file_id);
   return { content: [{ type: "text", text: "Removed from collection" }] };
 });
+server.tool("delete_collection", "Delete a collection (does not delete files, only the collection)", {
+  id: exports_external2.string().describe("Collection ID")
+}, async ({ id }) => {
+  const ok = deleteCollection(id);
+  return { content: [{ type: "text", text: ok ? `Collection ${id} deleted` : `Collection not found: ${id}` }] };
+});
 server.tool("list_projects", "List all projects", {
   status: exports_external2.enum(["active", "archived", "completed"]).optional().describe("Filter by status")
 }, async ({ status }) => {
@@ -59770,6 +62554,12 @@ server.tool("remove_from_project", "Remove a file from a project", {
   removeFromProject(project_id, file_id);
   return { content: [{ type: "text", text: "Removed from project" }] };
 });
+server.tool("delete_project", "Delete a project (does not delete files, only the project)", {
+  id: exports_external2.string().describe("Project ID")
+}, async ({ id }) => {
+  const ok = deleteProject(id);
+  return { content: [{ type: "text", text: ok ? `Project ${id} deleted` : `Project not found: ${id}` }] };
+});
 server.tool("list_machines", "List all known machines that have indexed files", {}, async () => {
   return { content: [{ type: "text", text: JSON.stringify(listMachines(), null, 2) }] };
 });
@@ -59788,7 +62578,7 @@ server.tool("get_file_url", "Get a pre-signed URL for temporary access to an S3
   const url = await getPresignedUrl(source, file.path, expires_in ?? 3600);
   return { content: [{ type: "text", text: url }] };
 });
-server.tool("get_file_content", "Read the content of a text file (local sources only, max 1MB)", {
+server.tool("get_file_content", "Read the content of a text file (local or S3 sources, max 1MB)", {
   id: exports_external2.string().describe("File ID"),
   max_bytes: exports_external2.number().optional().default(102400).describe("Max bytes to read (default 100KB)"),
   agent_id: exports_external2.string().optional().describe("Agent ID for activity tracking")
@@ -59799,25 +62589,53 @@ server.tool("get_file_content", "Read the content of a text file (local sources
   const source = getSource(file.source_id);
   if (!source)
     return { content: [{ type: "text", text: "Source not found" }], isError: true };
-  if (source.type !== "local")
-    return { content: [{ type: "text", text: "get_file_content only works with local sources" }], isError: true };
-  const fullPath = join10(source.path, file.path);
-  const { readFileSync: readFileSync5 } = await import("fs");
-  try {
-    const buf = readFileSync5(fullPath);
-    const slice = buf.slice(0, max_bytes ?? 102400);
-    const text = slice.toString("utf8");
-    const truncated = buf.length > (max_bytes ?? 102400);
-    if (agent_id)
-      logActivity({ agent_id, action: "read", file_id: id, metadata: { bytes_read: slice.length, truncated } });
-    return {
-      content: [{ type: "text", text: truncated ? `${text}
-
-[truncated \u2014 ${buf.length} bytes total, showing first ${max_bytes} bytes]` : text }]
-    };
-  } catch (e2) {
-    return { content: [{ type: "text", text: `Failed to read file: ${e2.message}` }], isError: true };
+  const limit = max_bytes ?? 102400;
+  let buf;
+  if (source.type === "local") {
+    const fullPath = join12(source.path, file.path);
+    const { readFileSync: readFileSync5 } = await import("fs");
+    try {
+      buf = readFileSync5(fullPath);
+    } catch (e2) {
+      return { content: [{ type: "text", text: `Failed to read file: ${e2.message}` }], isError: true };
+    }
+  } else if (source.type === "s3") {
+    try {
+      const { GetObjectCommand: GetObjectCommand3, S3Client: S3Client3 } = await Promise.resolve().then(() => (init_dist_es27(), exports_dist_es8));
+      const cfg = source.config;
+      const client = new S3Client3({
+        region: source.region ?? "us-east-1",
+        ...cfg.endpoint ? { endpoint: cfg.endpoint } : {},
+        ...cfg.accessKeyId ? { credentials: { accessKeyId: cfg.accessKeyId, secretAccessKey: cfg.secretAccessKey, sessionToken: cfg.sessionToken } } : {}
+      });
+      const resp = await client.send(new GetObjectCommand3({
+        Bucket: source.bucket,
+        Key: file.path,
+        Range: `bytes=0-${limit - 1}`
+      }));
+      if (!resp.Body)
+        return { content: [{ type: "text", text: "Empty response from S3" }], isError: true };
+      const chunks = [];
+      for await (const chunk of resp.Body) {
+        chunks.push(chunk);
+      }
+      buf = Buffer.concat(chunks);
+    } catch (e2) {
+      return { content: [{ type: "text", text: `Failed to read S3 file: ${e2.message}` }], isError: true };
+    }
+  } else {
+    return { content: [{ type: "text", text: `Unsupported source type: ${source.type}` }], isError: true };
   }
+  const slice = buf.slice(0, limit);
+  const text = slice.toString("utf8");
+  const truncated = buf.length > limit;
+  if (agent_id)
+    logActivity({ agent_id, action: "read", file_id: id, metadata: { bytes_read: slice.length, truncated } });
+  return {
+    content: [{ type: "text", text: truncated ? `${text}
+
+[truncated \u2014 ${buf.length} bytes total, showing first ${limit} bytes]` : text }]
+  };
 });
 server.tool("bulk_tag", "Add tags to multiple files at once (by IDs or search query)", {
   tags: exports_external2.array(exports_external2.string()).describe("Tag names to add"),
@@ -59851,9 +62669,9 @@ server.tool("describe_file", "Get file metadata + first lines of content in one
   let preview = "";
   if (source?.type === "local") {
     const { readFileSync: readFileSync5 } = await import("fs");
-    const { join: join11 } = await import("path");
+    const { join: join13 } = await import("path");
     try {
-      const fullPath = join11(source.path, file.path);
+      const fullPath = join13(source.path, file.path);
       const content = readFileSync5(fullPath, "utf8");
       preview = content.split(`
 `).slice(0, lines ?? 50).join(`
@@ -59884,10 +62702,10 @@ server.tool("move_file", "Move a file to a different path within the same source
     return { content: [{ type: "text", text: "Source not found" }], isError: true };
   if (source.type === "local") {
     const { renameSync, mkdirSync: mkdirSync4 } = await import("fs");
-    const { join: jp, dirname: dirname3 } = await import("path");
+    const { join: jp, dirname: dirname5 } = await import("path");
     const oldPath = jp(source.path, file.path);
     const newPath = jp(source.path, dest_path);
-    mkdirSync4(dirname3(newPath), { recursive: true });
+    mkdirSync4(dirname5(newPath), { recursive: true });
     renameSync(oldPath, newPath);
   }
   const { getDb: getMoveDb } = await Promise.resolve().then(() => (init_database(), exports_database));
@@ -59913,10 +62731,10 @@ server.tool("copy_file", "Copy a file to another source (local\u2192S3, S3\u2192
   const { join: jp } = await import("path");
   if (srcSource.type === "local" && dstSource.type === "local") {
     const { copyFileSync: copyFileSync2, mkdirSync: mkdirSync4 } = await import("fs");
-    const { dirname: dirname3 } = await import("path");
+    const { dirname: dirname5 } = await import("path");
     const src = jp(srcSource.path, file.path);
     const dst = jp(dstSource.path, finalDest);
-    mkdirSync4(dirname3(dst), { recursive: true });
+    mkdirSync4(dirname5(dst), { recursive: true });
     copyFileSync2(src, dst);
     const machine = getCurrentMachine();
     await indexLocalSource(dstSource, machine.id);
@@ -59927,9 +62745,9 @@ server.tool("copy_file", "Copy a file to another source (local\u2192S3, S3\u2192
     await indexS3Source(dstSource, machine.id);
   } else if (srcSource.type === "s3" && dstSource.type === "local") {
     const { mkdirSync: mkdirSync4 } = await import("fs");
-    const { dirname: dirname3 } = await import("path");
+    const { dirname: dirname5 } = await import("path");
     const dst = jp(dstSource.path, finalDest);
-    mkdirSync4(dirname3(dst), { recursive: true });
+    mkdirSync4(dirname5(dst), { recursive: true });
     await downloadFromS3(srcSource, file.path, dst);
     const machine = getCurrentMachine();
     await indexLocalSource(dstSource, machine.id);
@@ -60088,12 +62906,12 @@ server.tool("import_from_url", "Import a file from any URL (iCloud, Google Drive
         fileName = decodeURIComponent(urlName);
     }
     const { writeFileSync: writeFileSync2, mkdirSync: mkdirSync4 } = await import("fs");
-    const { join: joinPath, dirname: dirname3, basename: baseName, extname: extName } = await import("path");
+    const { join: joinPath, dirname: dirname5, basename: baseName, extname: extName } = await import("path");
     const body = Buffer.from(await resp.arrayBuffer());
     if (source.type === "local") {
       const destDir = source.path;
       const finalPath = dest_path ? joinPath(destDir, dest_path) : joinPath(destDir, fileName);
-      mkdirSync4(dirname3(finalPath), { recursive: true });
+      mkdirSync4(dirname5(finalPath), { recursive: true });
       writeFileSync2(finalPath, body);
       const machine = getCurrentMachine();
       await indexLocalSource(source, machine.id);
@@ -60139,11 +62957,11 @@ server.tool("import_from_local", "Import a file from any local path into a manag
   if (!existsSync8(srcPath))
     return { content: [{ type: "text", text: `File not found: ${srcPath}` }], isError: true };
   const { copyFileSync: copyFileSync2, renameSync, mkdirSync: mkDir } = await import("fs");
-  const { join: joinPath, dirname: dirname3, basename: baseName } = await import("path");
+  const { join: joinPath, dirname: dirname5, basename: baseName } = await import("path");
   const fileName = baseName(srcPath);
   if (source.type === "local") {
     const finalPath = dest_path ? joinPath(source.path, dest_path) : joinPath(source.path, fileName);
-    mkDir(dirname3(finalPath), { recursive: true });
+    mkDir(dirname5(finalPath), { recursive: true });
     if (copy)
       copyFileSync2(srcPath, finalPath);
     else
@@ -60244,6 +63062,121 @@ server.tool("bulk_import", "Import multiple files at once from URLs or local pat
     logActivity({ agent_id, action: "import", source_id: dest_source_id, metadata: { imported, failed } });
   return { content: [{ type: "text", text: JSON.stringify({ imported, failed, errors: errors3 }, null, 2) }] };
 });
+server.tool("resolve_id", "Resolve a partial ID to a full ID (prefix matching)", {
+  partial: exports_external2.string().describe("Partial ID (e.g. 'f_abc' or 'col_x')"),
+  type: exports_external2.enum(["files", "sources", "collections", "projects", "tags", "machines"]).describe("Entity type")
+}, async ({ partial, type }) => {
+  const { resolveId: resolveId2 } = await Promise.resolve().then(() => (init_resolve(), exports_resolve));
+  try {
+    const id = resolveId2(partial, type);
+    if (!id)
+      return { content: [{ type: "text", text: `No ${type.slice(0, -1)} found matching "${partial}"` }], isError: true };
+    return { content: [{ type: "text", text: id }] };
+  } catch (e2) {
+    return { content: [{ type: "text", text: e2.message }], isError: true };
+  }
+});
+server.tool("get_file_by_path", "Look up a file by its path within a source", {
+  source_id: exports_external2.string().describe("Source ID"),
+  path: exports_external2.string().describe("File path relative to source root")
+}, async ({ source_id, path }) => {
+  const file = getFileByPath(source_id, path);
+  if (!file)
+    return { content: [{ type: "text", text: `File not found: ${path} in source ${source_id}` }], isError: true };
+  const full = getFile(file.id);
+  return { content: [{ type: "text", text: JSON.stringify(full, null, 2) }] };
+});
+server.tool("recent_files", "Get files recently touched by agents (read, upload, tag, annotate, etc.)", {
+  agent_id: exports_external2.string().optional().describe("Filter by agent ID (omit for all agents)"),
+  limit: exports_external2.number().optional().default(20)
+}, async ({ agent_id, limit }) => {
+  const { getDb: getRecentDb } = await Promise.resolve().then(() => (init_database(), exports_database));
+  const db2 = getRecentDb();
+  const lim = limit ?? 20;
+  const query = agent_id ? "SELECT DISTINCT file_id, MAX(created_at) as last_touched FROM agent_activity WHERE file_id IS NOT NULL AND agent_id = ? GROUP BY file_id ORDER BY last_touched DESC LIMIT ?" : "SELECT DISTINCT file_id, MAX(created_at) as last_touched FROM agent_activity WHERE file_id IS NOT NULL GROUP BY file_id ORDER BY last_touched DESC LIMIT ?";
+  const params = agent_id ? [agent_id, lim] : [lim];
+  const rows = db2.query(query).all(params);
+  const files = rows.map((r2) => {
+    const f2 = getFile(r2.file_id);
+    return f2 ? { ...f2, last_touched: r2.last_touched } : null;
+  }).filter(Boolean);
+  return { content: [{ type: "text", text: JSON.stringify(files, null, 2) }] };
+});
+server.tool("list_deleted_files", "List soft-deleted files (trash)", {
+  source_id: exports_external2.string().optional(),
+  limit: exports_external2.number().optional().default(50),
+  offset: exports_external2.number().optional().default(0)
+}, async ({ source_id, limit, offset }) => {
+  const files = listFiles({ source_id, status: "deleted", limit, offset });
+  return { content: [{ type: "text", text: JSON.stringify(files, null, 2) }] };
+});
+server.tool("list_conflicts", "List files with sync conflicts", {
+  source_id: exports_external2.string().optional(),
+  limit: exports_external2.number().optional().default(50)
+}, async ({ source_id, limit }) => {
+  const { getDb: getConflictDb } = await Promise.resolve().then(() => (init_database(), exports_database));
+  const db2 = getConflictDb();
+  const lim = limit ?? 50;
+  const query = source_id ? "SELECT * FROM files WHERE sync_status = 'conflict' AND source_id = ? LIMIT ?" : "SELECT * FROM files WHERE sync_status = 'conflict' LIMIT ?";
+  const params = source_id ? [source_id, lim] : [lim];
+  const rows = db2.query(query).all(params);
+  return { content: [{ type: "text", text: JSON.stringify(rows, null, 2) }] };
+});
+server.tool("resolve_conflict", "Resolve a sync conflict by picking a side", {
+  file_id: exports_external2.string().describe("File ID with conflict"),
+  resolution: exports_external2.enum(["keep_local", "keep_remote", "mark_resolved"]).describe("How to resolve")
+}, async ({ file_id, resolution }) => {
+  const { getDb: getResDb } = await Promise.resolve().then(() => (init_database(), exports_database));
+  getResDb().run("UPDATE files SET sync_status = 'synced', sync_version = sync_version + 1 WHERE id = ?", [file_id]);
+  return { content: [{ type: "text", text: `Conflict resolved for ${file_id} (${resolution})` }] };
+});
+server.tool("purge_deleted", "Permanently remove soft-deleted files from the database", {
+  source_id: exports_external2.string().optional().describe("Limit to a specific source"),
+  older_than: exports_external2.string().optional().describe("Only purge files deleted before this date (ISO 8601)")
+}, async ({ source_id, older_than }) => {
+  const { getDb: getPurgeDb } = await Promise.resolve().then(() => (init_database(), exports_database));
+  const db2 = getPurgeDb();
+  const conditions = ["status = 'deleted'"];
+  const params = [];
+  if (source_id) {
+    conditions.push("source_id = ?");
+    params.push(source_id);
+  }
+  if (older_than) {
+    conditions.push("indexed_at <= ?");
+    params.push(older_than);
+  }
+  const result = db2.run(`DELETE FROM files WHERE ${conditions.join(" AND ")}`, params);
+  return { content: [{ type: "text", text: `Purged ${result.changes} deleted file(s)` }] };
+});
+server.tool("get_or_create_collection", "Find a collection by name, or create it if it doesn't exist", {
+  name: exports_external2.string(),
+  description: exports_external2.string().optional().default("")
+}, async ({ name, description }) => {
+  const { getDb: getGocDb } = await Promise.resolve().then(() => (init_database(), exports_database));
+  const db2 = getGocDb();
+  const existing = db2.query("SELECT id FROM collections WHERE name = ?").get(name);
+  if (existing) {
+    const c3 = getCollection(existing.id);
+    return { content: [{ type: "text", text: JSON.stringify(c3, null, 2) }] };
+  }
+  const c2 = createCollection(name, description);
+  return { content: [{ type: "text", text: JSON.stringify(c2, null, 2) }] };
+});
+server.tool("get_or_create_project", "Find a project by name, or create it if it doesn't exist", {
+  name: exports_external2.string(),
+  description: exports_external2.string().optional().default("")
+}, async ({ name, description }) => {
+  const { getDb: getGopDb } = await Promise.resolve().then(() => (init_database(), exports_database));
+  const db2 = getGopDb();
+  const existing = db2.query("SELECT id FROM projects WHERE name = ?").get(name);
+  if (existing) {
+    const p3 = getProject(existing.id);
+    return { content: [{ type: "text", text: JSON.stringify(p3, null, 2) }] };
+  }
+  const p2 = createProject(name, description);
+  return { content: [{ type: "text", text: JSON.stringify(p2, null, 2) }] };
+});
 server.tool("send_feedback", "Send feedback about this service", {
   message: exports_external2.string(),
   email: exports_external2.string().optional(),
@@ -60291,6 +63224,26 @@ server.tool("set_focus", "Set active project context for this agent session.", {
 server.tool("list_agents", "List all registered agents.", {}, async () => {
   return { content: [{ type: "text", text: JSON.stringify(listAgents()) }] };
 });
+server.tool("watch_source", "Start watching a local source for file changes (real-time indexing)", {
+  source_id: exports_external2.string().describe("Source ID (must be a local source)")
+}, async ({ source_id }) => {
+  const source = getSource(source_id);
+  if (!source)
+    return { content: [{ type: "text", text: `Source not found: ${source_id}` }], isError: true };
+  if (source.type !== "local")
+    return { content: [{ type: "text", text: "watch_source only works with local sources" }], isError: true };
+  const { watchSource: watchSource2 } = await Promise.resolve().then(() => (init_watcher(), exports_watcher));
+  const machine = getCurrentMachine();
+  watchSource2(source, machine.id);
+  return { content: [{ type: "text", text: `Watching ${source.name} (${source.path})` }] };
+});
+server.tool("unwatch_source", "Stop watching a source for file changes", {
+  source_id: exports_external2.string().describe("Source ID")
+}, async ({ source_id }) => {
+  const { unwatchSource: unwatchSource2 } = await Promise.resolve().then(() => (init_watcher(), exports_watcher));
+  unwatchSource2(source_id);
+  return { content: [{ type: "text", text: `Stopped watching source ${source_id}` }] };
+});
 server.tool("get_file_history", "Get all agent activity for a file", {
   file_id: exports_external2.string().describe("File ID"),
   after: exports_external2.string().optional().describe("Filter: activity after this date (ISO 8601)"),