@donezone/cli 0.1.44 → 0.1.48

package/dist/index.js

@@ -21452,6 +21452,452 @@ var require_dist2 = __commonJS((exports) => {
   global.eddsa = () => global._eddsa || (global._eddsa = new elliptic_1.eddsa("ed25519"));
 });
 
+// ../done-local-chain/node_modules/@cosmjs/encoding/build/ascii.js
+var require_ascii2 = __commonJS((exports) => {
+  function toAscii(input) {
+    const toNums = (str) => str.split("").map((x) => {
+      const charCode = x.charCodeAt(0);
+      if (charCode < 32 || charCode > 126) {
+        throw new Error("Cannot encode character that is out of printable ASCII range: " + charCode);
+      }
+      return charCode;
+    });
+    return Uint8Array.from(toNums(input));
+  }
+  function fromAscii(data) {
+    const fromNums = (listOfNumbers) => listOfNumbers.map((x) => {
+      if (x < 32 || x > 126) {
+        throw new Error("Cannot decode character that is out of printable ASCII range: " + x);
+      }
+      return String.fromCharCode(x);
+    });
+    return fromNums(Array.from(data)).join("");
+  }
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.fromAscii = exports.toAscii = undefined;
+  exports.toAscii = toAscii;
+  exports.fromAscii = fromAscii;
+});
+
+// ../done-local-chain/node_modules/@cosmjs/encoding/build/base64.js
+var require_base642 = __commonJS((exports) => {
+  function toBase64(data) {
+    return base64js.fromByteArray(data);
+  }
+  function fromBase64(base64String) {
+    if (!base64String.match(/^[a-zA-Z0-9+/]*={0,2}$/)) {
+      throw new Error("Invalid base64 string format");
+    }
+    return base64js.toByteArray(base64String);
+  }
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  } : function(o, v) {
+    o["default"] = v;
+  });
+  var __importStar = exports && exports.__importStar || function(mod) {
+    if (mod && mod.__esModule)
+      return mod;
+    var result = {};
+    if (mod != null) {
+      for (var k in mod)
+        if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+          __createBinding(result, mod, k);
+    }
+    __setModuleDefault(result, mod);
+    return result;
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.fromBase64 = exports.toBase64 = undefined;
+  var base64js = __importStar(require_base64_js());
+  exports.toBase64 = toBase64;
+  exports.fromBase64 = fromBase64;
+});
+
+// ../done-local-chain/node_modules/@cosmjs/encoding/node_modules/bech32/index.js
+var require_bech323 = __commonJS((exports, module) => {
+  function polymodStep(pre) {
+    var b = pre >> 25;
+    return (pre & 33554431) << 5 ^ -(b >> 0 & 1) & 996825010 ^ -(b >> 1 & 1) & 642813549 ^ -(b >> 2 & 1) & 513874426 ^ -(b >> 3 & 1) & 1027748829 ^ -(b >> 4 & 1) & 705979059;
+  }
+  function prefixChk(prefix) {
+    var chk = 1;
+    for (var i = 0;i < prefix.length; ++i) {
+      var c = prefix.charCodeAt(i);
+      if (c < 33 || c > 126)
+        return "Invalid prefix (" + prefix + ")";
+      chk = polymodStep(chk) ^ c >> 5;
+    }
+    chk = polymodStep(chk);
+    for (i = 0;i < prefix.length; ++i) {
+      var v = prefix.charCodeAt(i);
+      chk = polymodStep(chk) ^ v & 31;
+    }
+    return chk;
+  }
+  function encode(prefix, words, LIMIT) {
+    LIMIT = LIMIT || 90;
+    if (prefix.length + 7 + words.length > LIMIT)
+      throw new TypeError("Exceeds length limit");
+    prefix = prefix.toLowerCase();
+    var chk = prefixChk(prefix);
+    if (typeof chk === "string")
+      throw new Error(chk);
+    var result = prefix + "1";
+    for (var i = 0;i < words.length; ++i) {
+      var x2 = words[i];
+      if (x2 >> 5 !== 0)
+        throw new Error("Non 5-bit word");
+      chk = polymodStep(chk) ^ x2;
+      result += ALPHABET.charAt(x2);
+    }
+    for (i = 0;i < 6; ++i) {
+      chk = polymodStep(chk);
+    }
+    chk ^= 1;
+    for (i = 0;i < 6; ++i) {
+      var v = chk >> (5 - i) * 5 & 31;
+      result += ALPHABET.charAt(v);
+    }
+    return result;
+  }
+  function __decode(str, LIMIT) {
+    LIMIT = LIMIT || 90;
+    if (str.length < 8)
+      return str + " too short";
+    if (str.length > LIMIT)
+      return "Exceeds length limit";
+    var lowered = str.toLowerCase();
+    var uppered = str.toUpperCase();
+    if (str !== lowered && str !== uppered)
+      return "Mixed-case string " + str;
+    str = lowered;
+    var split = str.lastIndexOf("1");
+    if (split === -1)
+      return "No separator character for " + str;
+    if (split === 0)
+      return "Missing prefix for " + str;
+    var prefix = str.slice(0, split);
+    var wordChars = str.slice(split + 1);
+    if (wordChars.length < 6)
+      return "Data too short";
+    var chk = prefixChk(prefix);
+    if (typeof chk === "string")
+      return chk;
+    var words = [];
+    for (var i = 0;i < wordChars.length; ++i) {
+      var c = wordChars.charAt(i);
+      var v = ALPHABET_MAP[c];
+      if (v === undefined)
+        return "Unknown character " + c;
+      chk = polymodStep(chk) ^ v;
+      if (i + 6 >= wordChars.length)
+        continue;
+      words.push(v);
+    }
+    if (chk !== 1)
+      return "Invalid checksum for " + str;
+    return { prefix, words };
+  }
+  function decodeUnsafe() {
+    var res = __decode.apply(null, arguments);
+    if (typeof res === "object")
+      return res;
+  }
+  function decode(str) {
+    var res = __decode.apply(null, arguments);
+    if (typeof res === "object")
+      return res;
+    throw new Error(res);
+  }
+  function convert(data, inBits, outBits, pad) {
+    var value = 0;
+    var bits = 0;
+    var maxV = (1 << outBits) - 1;
+    var result = [];
+    for (var i = 0;i < data.length; ++i) {
+      value = value << inBits | data[i];
+      bits += inBits;
+      while (bits >= outBits) {
+        bits -= outBits;
+        result.push(value >> bits & maxV);
+      }
+    }
+    if (pad) {
+      if (bits > 0) {
+        result.push(value << outBits - bits & maxV);
+      }
+    } else {
+      if (bits >= inBits)
+        return "Excess padding";
+      if (value << outBits - bits & maxV)
+        return "Non-zero padding";
+    }
+    return result;
+  }
+  function toWordsUnsafe(bytes2) {
+    var res = convert(bytes2, 8, 5, true);
+    if (Array.isArray(res))
+      return res;
+  }
+  function toWords(bytes2) {
+    var res = convert(bytes2, 8, 5, true);
+    if (Array.isArray(res))
+      return res;
+    throw new Error(res);
+  }
+  function fromWordsUnsafe(words) {
+    var res = convert(words, 5, 8, false);
+    if (Array.isArray(res))
+      return res;
+  }
+  function fromWords(words) {
+    var res = convert(words, 5, 8, false);
+    if (Array.isArray(res))
+      return res;
+    throw new Error(res);
+  }
+  var ALPHABET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+  var ALPHABET_MAP = {};
+  for (z = 0;z < ALPHABET.length; z++) {
+    x = ALPHABET.charAt(z);
+    if (ALPHABET_MAP[x] !== undefined)
+      throw new TypeError(x + " is ambiguous");
+    ALPHABET_MAP[x] = z;
+  }
+  var x;
+  var z;
+  module.exports = {
+    decodeUnsafe,
+    decode,
+    encode,
+    toWordsUnsafe,
+    toWords,
+    fromWordsUnsafe,
+    fromWords
+  };
+});
+
+// ../done-local-chain/node_modules/@cosmjs/encoding/build/bech32.js
+var require_bech324 = __commonJS((exports) => {
+  function toBech32(prefix, data, limit) {
+    const address = bech32.encode(prefix, bech32.toWords(data), limit);
+    return address;
+  }
+  function fromBech32(address, limit = Infinity) {
+    const decodedAddress = bech32.decode(address, limit);
+    return {
+      prefix: decodedAddress.prefix,
+      data: new Uint8Array(bech32.fromWords(decodedAddress.words))
+    };
+  }
+  function normalizeBech32(address) {
+    const { prefix, data } = fromBech32(address);
+    return toBech32(prefix, data);
+  }
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  } : function(o, v) {
+    o["default"] = v;
+  });
+  var __importStar = exports && exports.__importStar || function(mod) {
+    if (mod && mod.__esModule)
+      return mod;
+    var result = {};
+    if (mod != null) {
+      for (var k in mod)
+        if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+          __createBinding(result, mod, k);
+    }
+    __setModuleDefault(result, mod);
+    return result;
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.normalizeBech32 = exports.fromBech32 = exports.toBech32 = undefined;
+  var bech32 = __importStar(require_bech323());
+  exports.toBech32 = toBech32;
+  exports.fromBech32 = fromBech32;
+  exports.normalizeBech32 = normalizeBech32;
+});
+
+// ../done-local-chain/node_modules/@cosmjs/encoding/build/hex.js
+var require_hex2 = __commonJS((exports) => {
+  function toHex(data) {
+    let out = "";
+    for (const byte of data) {
+      out += ("0" + byte.toString(16)).slice(-2);
+    }
+    return out;
+  }
+  function fromHex(hexstring) {
+    if (hexstring.length % 2 !== 0) {
+      throw new Error("hex string length must be a multiple of 2");
+    }
+    const out = new Uint8Array(hexstring.length / 2);
+    for (let i = 0;i < out.length; i++) {
+      const j = 2 * i;
+      const hexByteAsString = hexstring.slice(j, j + 2);
+      if (!hexByteAsString.match(/[0-9a-f]{2}/i)) {
+        throw new Error("hex string contains invalid characters");
+      }
+      out[i] = parseInt(hexByteAsString, 16);
+    }
+    return out;
+  }
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.fromHex = exports.toHex = undefined;
+  exports.toHex = toHex;
+  exports.fromHex = fromHex;
+});
+
+// ../done-local-chain/node_modules/@cosmjs/encoding/build/rfc3339.js
+var require_rfc33392 = __commonJS((exports) => {
+  function padded(integer, length = 2) {
+    return integer.toString().padStart(length, "0");
+  }
+  function fromRfc3339(str) {
+    const matches = rfc3339Matcher.exec(str);
+    if (!matches) {
+      throw new Error("Date string is not in RFC3339 format");
+    }
+    const year = +matches[1];
+    const month = +matches[2];
+    const day = +matches[3];
+    const hour = +matches[4];
+    const minute = +matches[5];
+    const second = +matches[6];
+    const milliSeconds = matches[7] ? Math.floor(+matches[7] * 1000) : 0;
+    let tzOffsetSign;
+    let tzOffsetHours;
+    let tzOffsetMinutes;
+    if (matches[8] === "Z") {
+      tzOffsetSign = 1;
+      tzOffsetHours = 0;
+      tzOffsetMinutes = 0;
+    } else {
+      tzOffsetSign = matches[8].substring(0, 1) === "-" ? -1 : 1;
+      tzOffsetHours = +matches[8].substring(1, 3);
+      tzOffsetMinutes = +matches[8].substring(4, 6);
+    }
+    const tzOffset = tzOffsetSign * (tzOffsetHours * 60 + tzOffsetMinutes) * 60;
+    const date = new Date;
+    date.setUTCFullYear(year, month - 1, day);
+    date.setUTCHours(hour, minute, second, milliSeconds);
+    return new Date(date.getTime() - tzOffset * 1000);
+  }
+  function toRfc3339(date) {
+    const year = date.getUTCFullYear();
+    const month = padded(date.getUTCMonth() + 1);
+    const day = padded(date.getUTCDate());
+    const hour = padded(date.getUTCHours());
+    const minute = padded(date.getUTCMinutes());
+    const second = padded(date.getUTCSeconds());
+    const ms = padded(date.getUTCMilliseconds(), 3);
+    return `${year}-${month}-${day}T${hour}:${minute}:${second}.${ms}Z`;
+  }
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.toRfc3339 = exports.fromRfc3339 = undefined;
+  var rfc3339Matcher = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2}):(\d{2})(\.\d{1,9})?((?:[+-]\d{2}:\d{2})|Z)$/;
+  exports.fromRfc3339 = fromRfc3339;
+  exports.toRfc3339 = toRfc3339;
+});
+
+// ../done-local-chain/node_modules/@cosmjs/encoding/build/utf8.js
+var require_utf82 = __commonJS((exports) => {
+  function toUtf8(str) {
+    return new TextEncoder().encode(str);
+  }
+  function fromUtf8(data, lossy = false) {
+    const fatal = !lossy;
+    return new TextDecoder("utf-8", { fatal }).decode(data);
+  }
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.fromUtf8 = exports.toUtf8 = undefined;
+  exports.toUtf8 = toUtf8;
+  exports.fromUtf8 = fromUtf8;
+});
+
+// ../done-local-chain/node_modules/@cosmjs/encoding/build/index.js
+var require_build2 = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.toUtf8 = exports.fromUtf8 = exports.toRfc3339 = exports.fromRfc3339 = exports.toHex = exports.fromHex = exports.toBech32 = exports.normalizeBech32 = exports.fromBech32 = exports.toBase64 = exports.fromBase64 = exports.toAscii = exports.fromAscii = undefined;
+  var ascii_1 = require_ascii2();
+  Object.defineProperty(exports, "fromAscii", { enumerable: true, get: function() {
+    return ascii_1.fromAscii;
+  } });
+  Object.defineProperty(exports, "toAscii", { enumerable: true, get: function() {
+    return ascii_1.toAscii;
+  } });
+  var base64_1 = require_base642();
+  Object.defineProperty(exports, "fromBase64", { enumerable: true, get: function() {
+    return base64_1.fromBase64;
+  } });
+  Object.defineProperty(exports, "toBase64", { enumerable: true, get: function() {
+    return base64_1.toBase64;
+  } });
+  var bech32_1 = require_bech324();
+  Object.defineProperty(exports, "fromBech32", { enumerable: true, get: function() {
+    return bech32_1.fromBech32;
+  } });
+  Object.defineProperty(exports, "normalizeBech32", { enumerable: true, get: function() {
+    return bech32_1.normalizeBech32;
+  } });
+  Object.defineProperty(exports, "toBech32", { enumerable: true, get: function() {
+    return bech32_1.toBech32;
+  } });
+  var hex_1 = require_hex2();
+  Object.defineProperty(exports, "fromHex", { enumerable: true, get: function() {
+    return hex_1.fromHex;
+  } });
+  Object.defineProperty(exports, "toHex", { enumerable: true, get: function() {
+    return hex_1.toHex;
+  } });
+  var rfc3339_1 = require_rfc33392();
+  Object.defineProperty(exports, "fromRfc3339", { enumerable: true, get: function() {
+    return rfc3339_1.fromRfc3339;
+  } });
+  Object.defineProperty(exports, "toRfc3339", { enumerable: true, get: function() {
+    return rfc3339_1.toRfc3339;
+  } });
+  var utf8_1 = require_utf82();
+  Object.defineProperty(exports, "fromUtf8", { enumerable: true, get: function() {
+    return utf8_1.fromUtf8;
+  } });
+  Object.defineProperty(exports, "toUtf8", { enumerable: true, get: function() {
+    return utf8_1.toUtf8;
+  } });
+});
+
 // ../../node_modules/fast-decode-uri-component/index.js
 var require_fast_decode_uri_component = __commonJS((exports, module) => {
   function decodeURIComponent2(uri) {
@@ -22221,6 +22667,9 @@ class AbstractTokenizer {
     return token.get(this.numBuffer, 0);
   }
   async ignore(length) {
+    if (length < 0) {
+      throw new RangeError("ignore length must be \u2265 0 bytes");
+    }
     if (this.fileInfo.size !== undefined) {
       const bytesLeft = this.fileInfo.size - this.position;
       if (length > bytesLeft) {
@@ -22319,6 +22768,9 @@ var init_ReadStreamTokenizer = __esm(() => {
       return bytesRead;
     }
     async ignore(length) {
+      if (length < 0) {
+        throw new RangeError("ignore length must be \u2265 0 bytes");
+      }
       const bufSize = Math.min(maxBufferSize, length);
       const buf = new Uint8Array(bufSize);
       let totBytesRead = 0;
@@ -24248,6 +24700,23 @@ var init_supported = __esm(() => {
 });
 
 // ../../node_modules/file-type/core.js
+function patchWebByobTokenizerClose(tokenizer) {
+  const streamReader = tokenizer?.streamReader;
+  if (streamReader?.constructor?.name !== "WebStreamByobReader") {
+    return tokenizer;
+  }
+  const { reader } = streamReader;
+  const cancelAndRelease = async () => {
+    await reader.cancel();
+    reader.releaseLock();
+  };
+  streamReader.close = cancelAndRelease;
+  streamReader.abort = async () => {
+    streamReader.interrupted = true;
+    await cancelAndRelease();
+  };
+  return tokenizer;
+}
 function getSafeBound(value, maximum, reason) {
   if (!Number.isFinite(value) || value < 0 || value > maximum) {
     throw new ParserHardLimitError(`${reason} has invalid size ${value} (maximum ${maximum} bytes)`);
@@ -24589,6 +25058,39 @@ function normalizeSampleSize(sampleSize) {
   }
   return Math.max(1, Math.trunc(sampleSize));
 }
+function readByobReaderWithSignal(reader, buffer, signal) {
+  if (signal === undefined) {
+    return reader.read(buffer);
+  }
+  signal.throwIfAborted();
+  return new Promise((resolve3, reject) => {
+    const cleanup = () => {
+      signal.removeEventListener("abort", onAbort);
+    };
+    const onAbort = () => {
+      const abortReason = signal.reason;
+      cleanup();
+      (async () => {
+        try {
+          await reader.cancel(abortReason);
+        } catch {
+        }
+      })();
+      reject(abortReason);
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    (async () => {
+      try {
+        const result = await reader.read(buffer);
+        cleanup();
+        resolve3(result);
+      } catch (error) {
+        cleanup();
+        reject(error);
+      }
+    })();
+  });
+}
 function normalizeMpegOffsetTolerance(mpegOffsetTolerance) {
   if (!Number.isFinite(mpegOffsetTolerance)) {
     return 0;
@@ -24739,7 +25241,10 @@ class FileTypeParser {
       ...this.tokenizerOptions
     };
   }
-  async fromTokenizer(tokenizer, detectionReentryCount = 0) {
+  createTokenizerFromWebStream(stream) {
+    return patchWebByobTokenizerClose(fromWebStream(stream, this.getTokenizerOptions()));
+  }
+  async parseTokenizer(tokenizer, detectionReentryCount = 0) {
     this.detectionReentryCount = detectionReentryCount;
     const initialPosition = tokenizer.position;
     for (const detector of this.detectors) {
@@ -24763,6 +25268,13 @@ class FileTypeParser {
       }
     }
   }
+  async fromTokenizer(tokenizer) {
+    try {
+      return await this.parseTokenizer(tokenizer);
+    } finally {
+      await tokenizer.close();
+    }
+  }
   async fromBuffer(input) {
     if (!(input instanceof Uint8Array || input instanceof ArrayBuffer)) {
       throw new TypeError(`Expected the \`input\` argument to be of type \`Uint8Array\` or \`ArrayBuffer\`, got \`${typeof input}\``);
@@ -24774,20 +25286,14 @@ class FileTypeParser {
     return this.fromTokenizer(fromBuffer(buffer, this.getTokenizerOptions()));
   }
   async fromBlob(blob) {
+    this.options.signal?.throwIfAborted();
     const tokenizer = fromBlob(blob, this.getTokenizerOptions());
-    try {
-      return await this.fromTokenizer(tokenizer);
-    } finally {
-      await tokenizer.close();
-    }
+    return this.fromTokenizer(tokenizer);
   }
   async fromStream(stream) {
-    const tokenizer = fromWebStream(stream, this.getTokenizerOptions());
-    try {
-      return await this.fromTokenizer(tokenizer);
-    } finally {
-      await tokenizer.close();
-    }
+    this.options.signal?.throwIfAborted();
+    const tokenizer = this.createTokenizerFromWebStream(stream);
+    return this.fromTokenizer(tokenizer);
   }
   async toDetectionStream(stream, options) {
     const sampleSize = normalizeSampleSize(options?.sampleSize ?? reasonableDetectionSizeInBytes);
@@ -24795,7 +25301,7 @@ class FileTypeParser {
     let firstChunk;
     const reader = stream.getReader({ mode: "byob" });
     try {
-      const { value: chunk, done } = await reader.read(new Uint8Array(sampleSize));
+      const { value: chunk, done } = await readByobReaderWithSignal(reader, new Uint8Array(sampleSize), this.options.signal);
       firstChunk = chunk;
       if (!done && chunk) {
         try {
@@ -24823,6 +25329,57 @@ class FileTypeParser {
     newStream.fileType = detectedFileType;
     return newStream;
   }
+  async detectGzip(tokenizer) {
+    if (this.gzipProbeDepth >= maximumNestedGzipProbeDepth) {
+      return {
+        ext: "gz",
+        mime: "application/gzip"
+      };
+    }
+    const gzipHandler = new GzipHandler(tokenizer);
+    const limitedInflatedStream = createByteLimitedReadableStream(gzipHandler.inflate(), maximumNestedGzipDetectionSizeInBytes);
+    const hasUnknownSize = hasUnknownFileSize(tokenizer);
+    let timeout;
+    let probeSignal;
+    let probeParser;
+    let compressedFileType;
+    if (hasUnknownSize) {
+      const timeoutController = new AbortController;
+      timeout = setTimeout(() => {
+        timeoutController.abort(new DOMException(`Operation timed out after ${unknownSizeGzipProbeTimeoutInMilliseconds} ms`, "TimeoutError"));
+      }, unknownSizeGzipProbeTimeoutInMilliseconds);
+      probeSignal = this.options.signal === undefined ? timeoutController.signal : AbortSignal.any([this.options.signal, timeoutController.signal]);
+      probeParser = new FileTypeParser({
+        ...this.options,
+        signal: probeSignal
+      });
+      probeParser.gzipProbeDepth = this.gzipProbeDepth + 1;
+    } else {
+      this.gzipProbeDepth++;
+    }
+    try {
+      compressedFileType = await (probeParser ?? this).fromStream(limitedInflatedStream);
+    } catch (error) {
+      if (error?.name === "AbortError" && probeSignal?.reason?.name !== "TimeoutError") {
+        throw error;
+      }
+    } finally {
+      clearTimeout(timeout);
+      if (!hasUnknownSize) {
+        this.gzipProbeDepth--;
+      }
+    }
+    if (compressedFileType?.ext === "tar") {
+      return {
+        ext: "tar.gz",
+        mime: "application/gzip"
+      };
+    }
+    return {
+      ext: "gz",
+      mime: "application/gzip"
+    };
+  }
   check(header, options) {
     return _check(this.buffer, header, options);
   }
@@ -24835,6 +25392,12 @@ class FileTypeParser {
       tokenizer.fileInfo.size = Number.MAX_SAFE_INTEGER;
     }
     this.tokenizer = tokenizer;
+    if (hasUnknownFileSize(tokenizer)) {
+      await tokenizer.peekBuffer(this.buffer, { length: 3, mayBeLess: true });
+      if (this.check([31, 139, 8])) {
+        return this.detectGzip(tokenizer);
+      }
+    }
     await tokenizer.peekBuffer(this.buffer, { length: 32, mayBeLess: true });
     if (this.check([66, 77])) {
       return {
@@ -24912,35 +25475,7 @@ class FileTypeParser {
       };
     }
     if (this.check([31, 139, 8])) {
-      if (this.gzipProbeDepth >= maximumNestedGzipProbeDepth) {
-        return {
-          ext: "gz",
-          mime: "application/gzip"
-        };
-      }
-      const gzipHandler = new GzipHandler(tokenizer);
-      const limitedInflatedStream = createByteLimitedReadableStream(gzipHandler.inflate(), maximumNestedGzipDetectionSizeInBytes);
-      let compressedFileType;
-      try {
-        this.gzipProbeDepth++;
-        compressedFileType = await this.fromStream(limitedInflatedStream);
-      } catch (error) {
-        if (error?.name === "AbortError") {
-          throw error;
-        }
-      } finally {
-        this.gzipProbeDepth--;
-      }
-      if (compressedFileType?.ext === "tar") {
-        return {
-          ext: "tar.gz",
-          mime: "application/gzip"
-        };
-      }
-      return {
-        ext: "gz",
-        mime: "application/gzip"
-      };
+      return this.detectGzip(tokenizer);
     }
     if (this.check([66, 90, 104])) {
       return {
@@ -24982,7 +25517,7 @@ class FileTypeParser {
         return;
       }
       this.detectionReentryCount++;
-      return this.fromTokenizer(tokenizer, this.detectionReentryCount);
+      return this.parseTokenizer(tokenizer, this.detectionReentryCount);
     }
     if (this.checkString("MP+")) {
       return {
@@ -26264,7 +26799,7 @@ class FileTypeParser {
     }
   }
 }
-var reasonableDetectionSizeInBytes = 4100, maximumMpegOffsetTolerance, maximumZipEntrySizeInBytes, maximumZipEntryCount = 1024, maximumZipBufferedReadSizeInBytes, maximumUntrustedSkipSizeInBytes, maximumUnknownSizePayloadProbeSizeInBytes, maximumZipTextEntrySizeInBytes, maximumNestedGzipDetectionSizeInBytes, maximumNestedGzipProbeDepth = 1, maximumId3HeaderSizeInBytes, maximumEbmlDocumentTypeSizeInBytes = 64, maximumEbmlElementPayloadSizeInBytes, maximumEbmlElementCount = 256, maximumPngChunkCount = 512, maximumPngStreamScanBudgetInBytes, maximumAsfHeaderObjectCount = 512, maximumTiffTagCount = 512, maximumDetectionReentryCount = 256, maximumPngChunkSizeInBytes, maximumAsfHeaderPayloadSizeInBytes, maximumTiffStreamIfdOffsetInBytes, maximumTiffIfdOffsetInBytes, recoverableZipErrorMessages, recoverableZipErrorMessagePrefixes, recoverableZipErrorCodes, ParserHardLimitError, zipDataDescriptorSignature = 134695760, zipDataDescriptorLengthInBytes = 16, zipDataDescriptorOverlapLengthInBytes, supportedExtensions, supportedMimeTypes;
+var reasonableDetectionSizeInBytes = 4100, maximumMpegOffsetTolerance, maximumZipEntrySizeInBytes, maximumZipEntryCount = 1024, maximumZipBufferedReadSizeInBytes, maximumUntrustedSkipSizeInBytes, maximumUnknownSizePayloadProbeSizeInBytes, maximumZipTextEntrySizeInBytes, maximumNestedGzipDetectionSizeInBytes, maximumNestedGzipProbeDepth = 1, unknownSizeGzipProbeTimeoutInMilliseconds = 100, maximumId3HeaderSizeInBytes, maximumEbmlDocumentTypeSizeInBytes = 64, maximumEbmlElementPayloadSizeInBytes, maximumEbmlElementCount = 256, maximumPngChunkCount = 512, maximumPngStreamScanBudgetInBytes, maximumAsfHeaderObjectCount = 512, maximumTiffTagCount = 512, maximumDetectionReentryCount = 256, maximumPngChunkSizeInBytes, maximumAsfHeaderPayloadSizeInBytes, maximumTiffStreamIfdOffsetInBytes, maximumTiffIfdOffsetInBytes, recoverableZipErrorMessages, recoverableZipErrorMessagePrefixes, recoverableZipErrorCodes, ParserHardLimitError, zipDataDescriptorSignature = 134695760, zipDataDescriptorLengthInBytes = 16, zipDataDescriptorOverlapLengthInBytes, supportedExtensions, supportedMimeTypes;
 var init_core2 = __esm(() => {
   init_lib3();
   init_core();
@@ -26295,7 +26830,8 @@ var init_core2 = __esm(() => {
     "ZIP entry count exceeds ",
     "Unsupported ZIP compression method:",
     "ZIP entry compressed data exceeds ",
-    "ZIP entry decompressed data exceeds "
+    "ZIP entry decompressed data exceeds ",
+    "Expected data-descriptor-signature at position "
   ];
   recoverableZipErrorCodes = new Set([
     "Z_BUF_ERROR",
@@ -26397,7 +26933,8 @@ var init_file_type = __esm(() => {
   init_core2();
   FileTypeParser2 = class FileTypeParser2 extends FileTypeParser {
     async fromStream(stream) {
-      const tokenizer = await (stream instanceof WebReadableStream ? fromWebStream(stream, this.getTokenizerOptions()) : fromStream2(stream, this.getTokenizerOptions()));
+      this.options.signal?.throwIfAborted();
+      const tokenizer = await (stream instanceof WebReadableStream ? this.createTokenizerFromWebStream(stream) : fromStream2(stream, this.getTokenizerOptions()));
       try {
         return await super.fromTokenizer(tokenizer);
       } catch (error) {
@@ -26406,10 +26943,13 @@ var init_file_type = __esm(() => {
         }
         throw error;
       } finally {
-        await tokenizer.close();
+        if (stream instanceof Readable && !stream.destroyed) {
+          stream.destroy();
+        }
       }
     }
     async fromFile(path) {
+      this.options.signal?.throwIfAborted();
       const fileHandle = await fs.open(path, fileSystemConstants.O_RDONLY | fileSystemConstants.O_NONBLOCK);
       const fileStat = await fileHandle.stat();
       if (!fileStat.isFile()) {
@@ -26423,41 +26963,65 @@ var init_file_type = __esm(() => {
           size: fileStat.size
         }
       });
-      try {
-        return await super.fromTokenizer(tokenizer);
-      } finally {
-        await tokenizer.close();
-      }
+      return super.fromTokenizer(tokenizer);
     }
     async toDetectionStream(readableStream, options = {}) {
       if (!(readableStream instanceof Readable)) {
         return super.toDetectionStream(readableStream, options);
       }
-      const sampleSize = normalizeSampleSize(options.sampleSize ?? reasonableDetectionSizeInBytes);
+      const { sampleSize = reasonableDetectionSizeInBytes } = options;
+      const { signal } = this.options;
+      const normalizedSampleSize = normalizeSampleSize(sampleSize);
+      signal?.throwIfAborted();
       return new Promise((resolve3, reject) => {
-        readableStream.on("error", reject);
-        readableStream.once("readable", () => {
+        let isSettled = false;
+        const cleanup = () => {
+          readableStream.off("error", onError);
+          readableStream.off("readable", onReadable);
+          signal?.removeEventListener("abort", onAbort);
+        };
+        const settle = (callback, value) => {
+          if (isSettled) {
+            return;
+          }
+          isSettled = true;
+          cleanup();
+          callback(value);
+        };
+        const onError = (error) => {
+          settle(reject, error);
+        };
+        const onAbort = () => {
+          if (!readableStream.destroyed) {
+            readableStream.destroy();
+          }
+          settle(reject, signal.reason);
+        };
+        const onReadable = () => {
           (async () => {
             try {
               const pass = new PassThrough;
               const outputStream = pipeline ? pipeline(readableStream, pass, () => {
               }) : readableStream.pipe(pass);
-              const chunk = readableStream.read(sampleSize) ?? readableStream.read() ?? new Uint8Array(0);
+              const chunk = readableStream.read(normalizedSampleSize) ?? readableStream.read() ?? new Uint8Array(0);
               try {
                 pass.fileType = await this.fromBuffer(chunk);
               } catch (error) {
                 if (error instanceof EndOfStreamError) {
                   pass.fileType = undefined;
                 } else {
-                  reject(error);
+                  settle(reject, error);
                 }
               }
-              resolve3(outputStream);
+              settle(resolve3, outputStream);
             } catch (error) {
-              reject(error);
+              settle(reject, error);
             }
           })();
-        });
+        };
+        readableStream.on("error", onError);
+        readableStream.once("readable", onReadable);
+        signal?.addEventListener("abort", onAbort, { once: true });
       });
     }
   };
@@ -26717,6 +27281,7 @@ import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:f
 import * as fs2 from "node:fs/promises";
 import path from "node:path";
 import { TextDecoder as TextDecoder2 } from "node:util";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // ../../node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
@@ -27793,6 +28358,7 @@ class DoneInstance {
 var Done = new DoneInstance;
 // ../done-local-chain/src/chain.ts
 var import_cosmwasm_vm_js = __toESM(require_dist2(), 1);
+var import_encoding = __toESM(require_build2(), 1);
 var import_backend = __toESM(require_backend(), 1);
 var import_bech32 = __toESM(require_dist(), 1);
 
@@ -28323,7 +28889,7 @@ class DoneLocalChain {
     const height = this.blockHeight;
     const blockTime = this.blockTime;
     try {
-      const region = record.vm[entrypoint](env, info, msg);
+      const region = entrypoint === "query" ? record.vm[entrypoint](env, msg) : record.vm[entrypoint](env, info, msg);
       const json = region?.json ?? { err: "contract returned empty response" };
       this.emitContractEvent(record, entrypoint, env, info, json, height, blockTime);
       return json;
@@ -28371,6 +28937,23 @@ class DoneLocalChain {
     view.setUint32(28, this.nextAddressNonce++);
     return import_bech32.bech32.encode(this.bech32Prefix, import_bech32.bech32.toWords(data));
   }
+  restoreStorage(address, entries) {
+    const record = this.contracts.get(address);
+    if (!record) {
+      throw new Error(`contract ${address} not found`);
+    }
+    const storage = record.backend.storage;
+    if (!(storage instanceof import_backend.BasicKVIterStorage)) {
+      return;
+    }
+    for (const entry of entries) {
+      if (!entry.key || !entry.value)
+        continue;
+      const keyBytes = import_encoding.fromBase64(entry.key);
+      const valueBytes = import_encoding.fromBase64(entry.value);
+      storage.set(keyBytes, valueBytes);
+    }
+  }
 }
 // ../done-local-chain/src/js-contract.ts
 import { readFileSync as readFileSync2 } from "node:fs";
@@ -42962,7 +43545,7 @@ var sharedRouteSchemas = {
 };
 // ../done-http-local/src/server.ts
 async function createDoneHttpLocalServer(config, chain) {
-  const runtime = chain ?? new DoneLocalChain;
+  const runtime = chain ?? loadChainWithArtifacts();
   if (config.scriptPath) {
     await deployJsContract({
       chain: runtime,
@@ -43153,6 +43736,9 @@ function unwrapQueryResult(result) {
   if (result.err) {
     throw new Error(result.err);
   }
+  if (typeof result.ok === "string") {
+    return decodeData(result.ok);
+  }
   if (result.ok?.data) {
     return decodeData(result.ok.data);
   }
@@ -43654,8 +44240,7 @@ interface SetGreetingBody {
 
 export default Done.serve()
   .instantiate(async () => {
-    const existing = await Greeting.load();
-    if (!existing) {
+    if (!(await Greeting.exists())) {
       await Greeting.save("${defaultGreeting}");
     }
   })
@@ -43794,7 +44379,7 @@ function updateDependencyIfPresent(pkg, name, version) {
 }
 async function syncWorkspaceDependencyVersions(targetDir) {
   await updatePackageJson(path.join(targetDir, "package.json"), (pkg) => {
-    ensureDependency(pkg, "devDependencies", "@donezone/cli", CLI_VERSION_RANGE);
+    ensureDependency(pkg, "devDependencies", "@donezone/cli", CLI_DEPENDENCY_SPEC);
     ensureDependency(pkg, "devDependencies", "done.zone", DONE_ZONE_VERSION_RANGE);
   });
   await updatePackageJson(path.join(targetDir, "frontend", "package.json"), (pkg) => {
@@ -44116,6 +44701,31 @@ async function readDevEnvFile(file2) {
   }
   return entries;
 }
+async function readStorageSnapshot(file2) {
+  try {
+    const raw = await fs2.readFile(file2, "utf8");
+    return JSON.parse(raw);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+function extractStorageEntries(snapshot) {
+  if (!snapshot?.entries) {
+    return [];
+  }
+  const entries = [];
+  for (const entry of snapshot.entries) {
+    const keyBase64 = entry.key?.base64;
+    const valueBase64 = entry.value?.base64;
+    if (!keyBase64 || !valueBase64)
+      continue;
+    entries.push({ key: keyBase64, value: valueBase64 });
+  }
+  return entries;
+}
 function toEnvVarKey(name) {
   return name.replace(/[^a-zA-Z0-9]+/g, "_").replace(/([a-z0-9])([A-Z])/g, "$1_$2").toUpperCase();
 }
@@ -44144,6 +44754,7 @@ function openBrowser(url) {
 var packageMetadata = readCliPackageMetadata();
 var CLI_VERSION = normalizeVersion(packageMetadata.version) ?? "0.0.0-spec";
 var CLI_VERSION_RANGE = toCaretRange(CLI_VERSION);
+var CLI_DEPENDENCY_SPEC = process.env.DONE_CLI_LOCAL_SPEC ?? CLI_VERSION_RANGE;
 var DONE_ZONE_VERSION = normalizeVersion(packageMetadata.doneZoneVersion) ?? CLI_VERSION;
 var DONE_ZONE_VERSION_RANGE = toCaretRange(DONE_ZONE_VERSION);
 var DONE_CLIENT_VERSION = normalizeVersion(packageMetadata.doneClientVersion) ?? CLI_VERSION;
@@ -44161,6 +44772,11 @@ if (typeof bunRuntime === "undefined") {
   process.exit(rerun.status ?? 1);
 }
 var DEFAULT_TEMPLATE_REPO = "https://github.com/mccallofthewild/done-template.git";
+var CLI_DIR = path.dirname(fileURLToPath2(import.meta.url));
+var CLI_ARTIFACTS_DIR = path.resolve(CLI_DIR, "..", "artifacts");
+if (!process.env.DONE_ARTIFACTS_DIR && existsSync2(CLI_ARTIFACTS_DIR)) {
+  process.env.DONE_ARTIFACTS_DIR = CLI_ARTIFACTS_DIR;
+}
 var program2 = new Command;
 program2.name("done").description("Done developer toolkit (spec-first stub)").version(CLI_VERSION);
 program2.command("build").description("Bundle Done contracts defined in done.json").option("-j, --contracts <path>", "Path to done.json").option("-n, --name <name...>", "Filter contract names").action(async (options) => {
@@ -44362,9 +44978,13 @@ class DoneDevOrchestrator {
       if (deployment.result.err) {
         throw new Error(`Failed to deploy ${contract.name}: ${deployment.result.err}`);
       }
+      const restored = await this.restoreStorageFromSnapshot(contract, deployment.address);
       contract.address = deployment.address;
       this.chain.advanceBlock();
       this.logInfo(`${import_picocolors.default.green("\u2022")} ${contract.name} deployed at ${deployment.address}`);
+      if (restored) {
+        this.logInfo(`  ${import_picocolors.default.dim("\u21BA state")}: restored snapshot for ${contract.name}`);
+      }
       await this.dumpContractStorage(contract);
     }
   }
@@ -44459,6 +45079,30 @@ class DoneDevOrchestrator {
     const filePath = path.join(storageDir, `${contract.slug}.json`);
     await writeJson(filePath, snapshot);
   }
+  async restoreStorageFromSnapshot(contract, address) {
+    if (!this.chain) {
+      return false;
+    }
+    const filePath = this.resolveStorageSnapshotPath(contract);
+    try {
+      const snapshot = await readStorageSnapshot(filePath);
+      const entries = extractStorageEntries(snapshot);
+      if (entries.length === 0) {
+        return false;
+      }
+      this.chain.restoreStorage(address, entries);
+      return true;
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        this.logWarn(`Unable to restore storage for ${contract.name}: ${error.message}`);
+      }
+      return false;
+    }
+  }
+  resolveStorageSnapshotPath(contract) {
+    const storageDir = path.join(this.options.workspace.root, ".done", "storage");
+    return path.join(storageDir, `${contract.slug}.json`);
+  }
   async launchFrontend() {
     const frontend = this.options.devConfig.frontend;
     if (!existsSync2(frontend.cwd)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@donezone/cli",
-  "version": "0.1.44",
+  "version": "0.1.48",
   "doneZoneVersion": "0.1.41",
   "doneClientVersion": "0.1.41",
   "private": false,