release: v2.6.0 bounded Node preflight and SmartArt inventory

Author: iguangfei

CHANGELOG.md

@@ -2,8 +2,24 @@
 
 All notable changes to DeckProbe are documented here.
 
+## [2.6.0] - 2026-09-09
+
+### Added
+
+- Node `probeFile(path, options, runtime)` with a 2500 ms default host deadline,
+  same-version native selection, WASM Worker fallback, cancellation, bounded input/output,
+  concurrency limits and independent host metrics. Existing two-argument calls are unchanged.
+- CLI `--max-input-bytes` for paths, stdin and JSONL sources.
+- Exact `powerpoint.smartart_data_part_count` inventory using existing Content Types/ZIP indexes.
+- Native/WASM parity, input cap, cancellation/deadline and semantic SmartArt regression checks.
+
 ## [Unreleased]
 
+### Changed
+
+- Keep the npm package lightweight by omitting source maps and TypeScript source
+  files from published tarballs, with a packaging regression check.
+
 ## [2.5.0] - 2026-09-03
 
 ### Added

Cargo.lock

@@ -15,7 +15,7 @@ members = [
 resolver = "2"
 
 [workspace.package]
-version = "2.5.0"
+version = "2.6.0"
 edition = "2024"
 license = "Apache-2.0"
 repository = "https://github.com/deckflow/deckprobe"

Cargo.toml

@@ -1,6 +1,6 @@
 use std::collections::BTreeMap;
 use std::fs::File;
-use std::io::{BufRead, Read, Write};
+use std::io::{BufRead, Read, Seek, SeekFrom, Write};
 use std::path::{Path, PathBuf};
 use std::process::ExitCode;
 
@@ -175,7 +175,11 @@ struct Cli {
     )]
     max_archive_entries: Option<usize>,
 
-    /// Wall-clock budget in milliseconds.
+    /// Maximum source file or stdin size before parsing (separate from physical read budget).
+    #[arg(long, value_name = "BYTES", help_heading = "Resource limits")]
+    max_input_bytes: Option<u64>,
+
+    /// Cooperative engine budget in milliseconds; not a hard process deadline.
     #[arg(
         short = 'T',
         long,
@@ -424,7 +428,21 @@ fn run(cli: Cli) -> deckprobe_core::Result<u8> {
         None => {}
     }
 
-    let options = probe_options(&cli)?;
+    if cli.max_input_bytes == Some(0) {
+        return Err(DeckProbeError::InvalidRequest(
+            "max-input-bytes must be positive".into(),
+        ));
+    }
+    let mut options = probe_options(&cli)?;
+    if cli.input.as_ref().is_some_and(|p| p.as_os_str() == "-")
+        && let Some(cap) = cli.max_input_bytes
+    {
+        let current = options
+            .budget
+            .max_physical_bytes
+            .unwrap_or(Budget::for_level(options.level).max_physical_bytes);
+        options.budget.max_physical_bytes = Some(current.min(cap));
+    }
     if cli.jsonl {
         return run_jsonl(&cli, &options);
     }
@@ -447,7 +465,7 @@ fn run(cli: Cli) -> deckprobe_core::Result<u8> {
                 "--stdin-name is only valid when INPUT is '-'".to_owned(),
             ));
         }
-        std::sync::Arc::new(PathSource::open(input, None)?)
+        std::sync::Arc::new(PathSource::bounded(input, None, cli.max_input_bytes)?)
     };
 
     let report = probe(source, options)?;
@@ -565,7 +583,7 @@ fn run_jsonl(cli: &Cli, options: &ProbeOptions) -> deckprobe_core::Result<u8> {
                     "JSONL line {line_number} is invalid: {error}"
                 ))
             })
-            .and_then(|input| jsonl_source(input, options))
+            .and_then(|input| jsonl_source(input, options, cli.max_input_bytes))
             .and_then(|source| probe(source, options.clone()));
         match outcome {
             Ok(report) => {
@@ -593,27 +611,46 @@ fn run_jsonl(cli: &Cli, options: &ProbeOptions) -> deckprobe_core::Result<u8> {
 fn jsonl_source(
     input: JsonlInput,
     options: &ProbeOptions,
+    max_input_bytes: Option<u64>,
 ) -> deckprobe_core::Result<std::sync::Arc<dyn ProbeSource>> {
     match input {
-        JsonlInput::Path(path) => Ok(std::sync::Arc::new(PathSource::open(path, None)?)),
+        JsonlInput::Path(path) => Ok(std::sync::Arc::new(PathSource::bounded(
+            path,
+            None,
+            max_input_bytes,
+        )?)),
         JsonlInput::Record {
             path: Some(path),
             name,
             data_base64: None,
-        } => Ok(std::sync::Arc::new(PathSource::open(path, name)?)),
+        } => Ok(std::sync::Arc::new(PathSource::bounded(
+            path,
+            name,
+            max_input_bytes,
+        )?)),
         JsonlInput::Record {
             path: None,
             name: Some(name),
             data_base64: Some(data),
         } => {
+            let mut budget = Budget::for_level(options.level);
+            options.budget.apply_to(&mut budget);
+            let limit = max_input_bytes
+                .unwrap_or(u64::MAX)
+                .min(budget.max_physical_bytes);
+            if data.len() as u64 > limit.saturating_add(2).saturating_div(3).saturating_mul(4) {
+                return Err(DeckProbeError::BudgetExceeded(
+                    "JSONL input exceeds size limit".into(),
+                ));
+            }
             let bytes = base64::engine::general_purpose::STANDARD
                 .decode(data)
                 .map_err(|error| {
                     DeckProbeError::InvalidRequest(format!("invalid JSONL base64 payload: {error}"))
                 })?;
             let mut budget = Budget::for_level(options.level);
             options.budget.apply_to(&mut budget);
-            if bytes.len() as u64 > budget.max_physical_bytes {
+            if bytes.len() as u64 > limit {
                 return Err(DeckProbeError::BudgetExceeded(format!(
                     "JSONL byte payload size {} exceeds physical read budget {}",
                     bytes.len(),
@@ -636,15 +673,23 @@ struct PathSource {
     path: PathBuf,
     display_name: String,
     file_size: u64,
+    max_input_bytes: Option<u64>,
+    modified: Option<std::time::SystemTime>,
 }
 
 impl PathSource {
-    fn open(
+    fn bounded(
         path: impl Into<PathBuf>,
         display_name: Option<String>,
+        max_input_bytes: Option<u64>,
     ) -> deckprobe_core::Result<Self> {
         let path = path.into();
         let metadata = std::fs::metadata(&path)?;
+        if max_input_bytes.is_some_and(|cap| metadata.len() > cap) {
+            return Err(DeckProbeError::BudgetExceeded(
+                "source exceeds max-input-bytes".into(),
+            ));
+        }
         if !metadata.is_file() {
             return Err(DeckProbeError::InvalidRequest(format!(
                 "input is not a regular file: {}",
@@ -661,6 +706,8 @@ impl PathSource {
             path,
             display_name,
             file_size: metadata.len(),
+            max_input_bytes,
+            modified: metadata.modified().ok(),
         })
     }
 }
@@ -679,7 +726,46 @@ impl ProbeSource for PathSource {
     }
 
     fn open(&self) -> deckprobe_core::Result<BoxedProbeReader> {
-        Ok(Box::new(File::open(&self.path)?))
+        let file = File::open(&self.path)?;
+        if self.max_input_bytes.is_some() {
+            let metadata = file.metadata()?;
+            if !metadata.is_file()
+                || metadata.len() != self.file_size
+                || metadata.modified().ok() != self.modified
+            {
+                return Err(DeckProbeError::Io(std::io::Error::other(
+                    "source changed during probe",
+                )));
+            }
+            return Ok(Box::new(CheckedFile {
+                file,
+                size: self.file_size,
+                modified: self.modified,
+            }));
+        }
+        Ok(Box::new(file))
+    }
+}
+
+struct CheckedFile {
+    file: File,
+    size: u64,
+    modified: Option<std::time::SystemTime>,
+}
+impl Read for CheckedFile {
+    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+        let meta = self.file.metadata()?;
+        if meta.len() != self.size || meta.modified().ok() != self.modified {
+            return Err(std::io::Error::other("source changed during probe"));
+        }
+        let position = self.file.stream_position()?;
+        let len = buf.len().min(self.size.saturating_sub(position) as usize);
+        self.file.read(&mut buf[..len])
+    }
+}
+impl Seek for CheckedFile {
+    fn seek(&mut self, pos: SeekFrom) -> std::io::Result<u64> {
+        self.file.seek(pos)
     }
 }
 

crates/deckprobe-cli/src/main.rs

@@ -614,6 +614,7 @@ fn is_asset_target(target: &str) -> bool {
         "media",
         "font",
         "attachment",
+        "smartart",
         "embedded",
     ]
     .iter()

crates/deckprobe-engine/src/lib.rs

@@ -419,6 +419,33 @@ impl<R: Read + Seek> OoxmlSession<R> {
         Ok(parts)
     }
 
+    pub fn unique_content_type_part_count(
+        &mut self,
+        context: &ProbeContext,
+        content_type: &str,
+    ) -> Result<usize> {
+        if self.content_types_cache.is_none() {
+            self.part_content_types(context)?;
+        }
+        let types = self
+            .content_types_cache
+            .as_ref()
+            .expect("content types loaded");
+        let mut found = BTreeSet::new();
+        for name in &self.entry_names {
+            context.check_time()?;
+            let name = name.trim_start_matches('/').to_ascii_lowercase();
+            let effective = types.overrides.get(&name).or_else(|| {
+                name.rsplit_once('.')
+                    .and_then(|(_, ext)| types.defaults.get(ext))
+            });
+            if effective.is_some_and(|value| value.eq_ignore_ascii_case(content_type)) {
+                found.insert(name);
+            }
+        }
+        Ok(found.len())
+    }
+
     pub fn unique_image_asset_part_count(
         &mut self,
         context: &ProbeContext,