.ai import: type that ends a clipping group without a clipping path clips it

Illustrator writes a clipping mask of type from the text document as a
clipping group (`q` ... `Q`) with no clipping path (`W`), the text object
(`/AI11Text`) last. The reader took only `W` paths (and legacy type in
rendering modes 4 to 7) as clipping paths, so it read such a group unclipped:
its art painted past the letters, and where the layers then differed too much
from the page the file opened as its page.

- `Reader::end_container` records each clipping group with no clipping path
  whose last object is a text slot (not the type a look draws) in
  `Structure::type_clips`, by the group's id. The group is still read as it is:
  the slot is filled later.
- `clip_by_type` (crates/eps/src/import/ai/read.rs) moves the type to the
  front as the group's clipping path once its slot became one text object that
  is still the group's last object. A slot left empty or filled with several
  objects (type and the strokes the page draws around it) leaves the group as
  read, unclipped, as before.
- The layers apply it after `fill_slots`; such type is never weighed as type
  the page doesn't draw (`MADE` is taken off), since the page shows it by what
  it clips. Envelopes of type apply it to their contents after `put_type`, so
  one opens live where its drawn art shows the clip (`WarpedType::type_clips`).

Measured on 224 garment files we own (used locally, never committed): 14 renders
change; 12 come closer to the file's own page (for example 15.7 % → 0.07 %,
26.5 % → 0.28 %, 58.5 % → 1.4 % of the page differing), one file has no PDF
content to compare with, and in one the texture inside a word changes along
the letters' edges (0.35 % → 0.56 %). Envelopes of type that open live stay at
185; no file opens another way and no note changes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
jmvergesandClaude Opus 5.5 committed 2026-11-17 07:42:46 +00:00
1 parent b4d45f2b0d
commit f71fe2e5d8
10 files changed
+243 -6

No files matched your search

+1 -1
View File
@@ -62,7 +62,7 @@ pub use read::{
palette, read_beside, read_in, symbols, variables,
};
pub(crate) use read::is_look_slot;
pub(crate) use read::{clip_by_type, is_look_slot};
pub(crate) use style::{MAX_LISTED, MAX_LISTED_NAME, warp_number};
#[cfg(test)]
+4
View File
@@ -692,6 +692,8 @@ pub struct WarpedType {
pub(super) checks: usize,
pub(super) spent: Spent,
pub(super) page: Option<Rect>,
/// [`super::Structure::type_clips`]: type in an envelope's contents clips its clipping group too.
pub(super) type_clips: HashMap<NodeId, NodeId>,
/// The envelopes of type that may open live in layers built without a page, by their place
/// among them ([`Self::open_alone`]): none when `None`.
pub(super) alone: Option<BTreeSet<usize>>,
@@ -811,8 +813,10 @@ impl WarpedType {
texts.insert(slot, text);
hidden.push(id);
}
let typed = |slot: NodeId| texts.get(&slot).map(|t| t.id);
for n in before.iter_mut().chain(inner.iter_mut()) {
put_type(n, &texts);
super::clip_by_type(n, &self.type_clips, &typed, &mut |_| ());
}
// A warp that VectorCraft's own warp doesn't draw as its drawn art may still draw as the
// grid the file saves for it: then it opens as a mesh envelope on that grid.
+41
View File
@@ -193,6 +193,10 @@ pub struct Structure {
pub unread_elsewhere: Vec<(NodeId, Rect)>,
/// The names of text objects, by their slot's id.
pub slot_names: HashMap<NodeId, String>,
/// The clipping groups whose type clips them, by the group's id: the text slot of that type,
/// the group's last object ([`Reader::end_container`]). Once the slot holds its type, the type
/// clips the group ([`clip_by_type`]).
pub type_clips: HashMap<NodeId, NodeId>,
/// Where the drawn looks lay that objects read with their art style took the place of (the
/// document's coordinates): the page draws Illustrator's rendering of those styles there.
pub restyled: Vec<Rect>,
@@ -660,6 +664,8 @@ struct Reader<'a> {
obj_hidden: bool,
/// The names of text objects, by their slot's id.
slot_names: HashMap<NodeId, String>,
/// [`Structure::type_clips`].
type_clips: HashMap<NodeId, NodeId>,
/// [`Structure::xml_ids`].
xml_ids: HashMap<String, Option<NodeId>>,
/// The bytes of the ids in `xml_ids`.
@@ -730,6 +736,40 @@ pub(crate) fn is_look_slot(name: Option<&str>) -> bool {
name == Some(document::LOOK_SLOT)
}
/// Make the clipping groups of [`Structure::type_clips`] in `n` and its groups clip by their type,
/// once their slots are filled: where a group's slot became one text object (`typed` gives its id by
/// the slot's) that is still the group's last object, that text object moves to the front as its
/// clipping path, and `clipping` is called on it. Where the slot was left empty or became several
/// objects, the group stays as read, unclipped. How many groups clip.
pub(crate) fn clip_by_type(
n: &mut Node,
clips: &HashMap<NodeId, NodeId>,
typed: &impl Fn(NodeId) -> Option<NodeId>,
clipping: &mut impl FnMut(&mut Node),
) -> usize {
if clips.is_empty() || matches!(n.kind, NodeKind::Compound { .. }) {
return 0;
}
let mut made = 0;
if let Some(children) = n.children_mut() {
for c in children.iter_mut().filter(|c| c.children().is_some_and(|k| !k.is_empty())) {
made += clip_by_type(Arc::make_mut(c), clips, typed, clipping);
}
}
let Some(text) = clips.get(&n.id).and_then(|slot| typed(*slot)) else { return made };
if let NodeKind::Group { children, clip } = &mut n.kind
&& !*clip
&& children.last().is_some_and(|last| last.id == text && matches!(last.kind, NodeKind::Text(_)))
&& let Some(mut last) = children.pop()
{
clipping(Arc::make_mut(&mut last));
children.insert(0, last);
*clip = true;
made += 1;
}
made
}
impl<'a> Reader<'a> {
/// A reader of the editing data `data` as a whole, with the names its gradients and patterns
/// get in the document and its art styles found first ([`swatch_names`]): the symbols defined
@@ -851,6 +891,7 @@ impl<'a> Reader<'a> {
done: false,
obj_hidden: false,
slot_names: HashMap::new(),
type_clips: HashMap::new(),
xml_ids: HashMap::new(),
xml_id_bytes: 0,
art_size: None,
@@ -134,6 +134,15 @@ impl<'a> Reader<'a> {
}
return Ok(());
}
// A clipping group (`q` … `Q`) with no clipping path whose last object is type: that type is
// its clipping path, as Illustrator writes a clipping mask of type made from the text
// document (`/AI11Text`), which has no `W`. The slot is filled later ([`clip_by_type`]).
let type_clip = match kids.last() {
Some(last) if matches!(kind, Kind::Clip) && clips.is_empty() && !super::is_look_slot(last.name.as_deref()) => {
slot_of(last.name.as_deref()).map(|_| last.id)
}
_ => None,
};
// A compound path of clipping paths clips its clipping group.
let clipping = matches!(kind, Kind::Compound) && !clips.is_empty();
self.group_ended = !matches!(kind, Kind::Compound);
@@ -179,6 +188,9 @@ impl<'a> Reader<'a> {
if clipping && let Some(f) = self.frames.last_mut() {
f.clips.push(f.children.len());
}
if let Some(slot) = type_clip {
self.type_clips.insert(node.id, slot);
}
if compound_members {
self.compound_groups.insert(node.id);
}
@@ -1380,6 +1380,7 @@ impl<'a> Reader<'a> {
unread: self.unread,
unread_elsewhere: self.unread_elsewhere,
slot_names: self.slot_names,
type_clips: self.type_clips.clone(),
restyled: self.restyled,
placeholders: self.placeholders,
placed_elsewhere: self.placed_elsewhere,
@@ -1392,6 +1393,7 @@ impl<'a> Reader<'a> {
spent: self.envelope_spent,
page,
alone: None,
type_clips: self.type_clips,
},
styles_read,
text_patterns,
+65 -1
View File
@@ -3741,6 +3741,70 @@ fn placed_files_are_linked_images_showing_their_preview() {
assert!(read(stream(&layer("~\n")).as_bytes()).unwrap_err().contains("`~`"));
}
/// Type made a clipping mask: a clipping group (`q` … `Q`) with no clipping path, whose last object
/// is a text object, is clipped by that type once its slot holds it, the type first as its
/// clipping path. Anything else stays as it was read.
#[test]
fn type_that_ends_a_clipping_group_without_a_clipping_path_clips_it() {
let text = |story: u32| format!("/AI11Text :\n0 /FreeUndo ,\n0 /FrameIndex ,\n{story} /StoryIndex ,\n;\n");
let square = format!("{RED}{}f\n", rect_path(0.0, 0.0, 10.0, 10.0));
let clipper = format!("{RED}{}h W n\n", rect_path(2.0, 2.0, 8.0, 8.0));
let r = read_ok(&layer(&format!("q\n{square}{}Q\n", text(4))));
let a = art(&r.doc);
let [group] = a.as_slice() else { panic!("{a:#?}") };
let slot = group.children().and_then(|c| c.last()).map(|n| n.id).unwrap();
assert!(matches!(group.kind, NodeKind::Group { clip: false, .. }), "read as it is, until the slot holds its type");
assert_eq!(r.type_clips.get(&group.id), Some(&slot));
assert_eq!(r.warped_type.type_clips, r.type_clips, "envelopes' contents are clipped by their type too");
// Filled with one text object, the slot's type clips the group.
let typed = |doc: &Document, one: bool| {
let mut layer = (*doc.layers[0]).clone();
let mut n = 0;
let put = |n: &mut Node| {
if let NodeKind::Group { children, .. } = &mut n.kind
&& let Some(last) = children.last_mut()
&& last.id == slot
{
let t = Node::new(
vectorcraft_doc::NodeId(9_000),
NodeKind::Text(Box::new(vectorcraft_doc::TextObject::point(kurbo::Point::ZERO, "M", Default::default()))),
);
if one {
*last = Arc::new(t);
} else {
let mut stroke = t.clone();
stroke.id = vectorcraft_doc::NodeId(9_001);
*last = Arc::new(t);
children.push(Arc::new(stroke));
}
}
};
layer.children_mut().unwrap().iter_mut().for_each(|c| put(Arc::make_mut(c)));
let clipped = clip_by_type(&mut layer, &r.type_clips, &|s| (s == slot).then_some(vectorcraft_doc::NodeId(9_000)), &mut |_| n += 1);
(layer, clipped, n)
};
let (layer_one, clipped, called) = typed(&r.doc, true);
assert_eq!((clipped, called), (1, 1));
let g = &layer_one.children().unwrap()[0];
let NodeKind::Group { children, clip: true } = &g.kind else { panic!("{g:#?}") };
assert!(matches!(children[0].kind, NodeKind::Text(_)) && matches!(children[1].kind, NodeKind::Path { .. }), "{children:#?}");
// Several objects in its place (the type and strokes round it): the group stays unclipped.
let (layer_two, clipped, _) = typed(&r.doc, false);
assert_eq!(clipped, 0);
assert!(matches!(layer_two.children().unwrap()[0].kind, NodeKind::Group { clip: false, .. }));
// A clipping path in the group clips it, not the type; type that isn't last doesn't; nor does a
// group (`u` … `U`) or the type a look draws.
for body in [
format!("q\n{square}{clipper}{}Q\n", text(4)),
format!("q\n{}{square}Q\n", text(4)),
format!("u\n{square}{}U\n", text(4)),
format!("q\n{square}/AI11Text :\n1 /FreeUndo ,\n0 /FrameIndex ,\n0 /StoryIndex ,\n;\nQ\n"),
] {
let r = read_ok(&layer(&body));
assert!(r.type_clips.is_empty(), "{body}: {:?}", r.type_clips);
}
}
#[test]
fn text_objects_are_slots_named_after_their_story() {
let words = "/AI11Text :\n0 /FreeUndo ,\n0 /FrameIndex ,\n3 /StoryIndex ,\n;\n%_/ArtDictionary :\n%_/XMLUID : (Title) ; (AI10_ArtUID) ,\n%_;\n";
@@ -8580,7 +8644,7 @@ fn warped_type_on_the_page_spends_what_is_left_of_the_budget() {
let copy = |w: &super::envelope::WarpedLook| super::envelope::WarpedLook { slot: w.slot, look: w.look.clone(), left_out: None };
let page = Some(Rect::new(0.0, 60.0, 60.0, 100.0));
let settle = |w: &super::envelope::WarpedLook, spent| {
let warped = super::envelope::WarpedType { looks: vec![copy(w)], envelopes: vec![], checks: 1, spent, page, alone: None };
let warped = super::envelope::WarpedType { looks: vec![copy(w)], checks: 1, spent, page, ..Default::default() };
warped.settle(&mut doc.clone(), Some, &Default::default(), &mut vec![])
};
let spent = || super::envelope::Spent { any: MAX_DIFFERENCE / 2.0, solid: MAX_SOLID_DIFFERENCE / 2.0 };
+26
View File
@@ -329,6 +329,7 @@ pub(super) fn build_weighing(
unread,
unread_elsewhere,
slot_names,
type_clips,
restyled,
placeholders,
placed_elsewhere,
@@ -527,6 +528,7 @@ pub(super) fn build_weighing(
let mut made = vec![];
let mut filled = std::collections::HashMap::new();
fill_slots(&mut doc, &mut layers, &mut content.into_iter(), &slot_names, &mut empty, &mut made, &mut vec![], &mut filled);
clip_by_type(&mut layers, &type_clips, &filled);
doc.layers = layers;
made.sort();
let threaded_frames: BTreeSet<NodeId> =
@@ -2155,6 +2157,30 @@ fn unmark(nodes: &mut [Arc<Node>], shown: bool, prints: bool, found: &mut Vec<(N
}
}
/// Make the clipping groups in `layers` that their type clips ([`Structure::type_clips`]) clip by it,
/// where its slot became one text object (`filled`). The page shows that type by what it clips, so
/// it is never weighed as type the page doesn't draw ([`prune_unseen`]).
fn clip_by_type(
layers: &mut [Arc<Node>],
type_clips: &std::collections::HashMap<NodeId, NodeId>,
filled: &std::collections::HashMap<NodeId, Filled>,
) {
let one = |slot: NodeId| {
filled.get(&slot).and_then(|f| match f.objects.as_slice() {
[id] => Some(*id),
_ => None,
})
};
let mut seen = |n: &mut Node| {
if let Some(name) = n.name.as_deref().and_then(|m| m.strip_prefix(MADE)) {
n.name = (!name.is_empty()).then(|| name.to_string());
}
};
for l in layers {
ai::clip_by_type(Arc::make_mut(l), type_clips, &one, &mut seen);
}
}
/// Take object `id` out of `nodes` (`hide`: leave it, hidden); whether it was there.
fn take_out(nodes: &mut Vec<Arc<Node>>, id: NodeId, hide: bool) -> bool {
if let Some(i) = nodes.iter().position(|n| n.id == id) {
+87 -1
View File
@@ -5887,12 +5887,18 @@ fn type_envelope_on(keys: &str, shape: &str, drawn: &str, after: &str) -> String
/// [`type_envelope_on`] around the type of story `story`.
fn type_envelope_on_story(story: u32, keys: &str, shape: &str, drawn: &str, after: &str) -> String {
type_envelope_holding(keys, shape, &format!("{}{after}", text_object(story)), drawn)
}
/// [`type_envelope_on`] whose contents are `contents` (on plain lines, written on `%_` ones), which
/// hold its text objects.
fn type_envelope_holding(keys: &str, shape: &str, contents: &str, drawn: &str) -> String {
let hidden = |s: &str| -> String { s.lines().map(|l| format!("%_{l}\n")).collect() };
format!(
"{}{}%_X=\n{}%_X+\n%_ (AIDeformArtKey) ,\n%_1 /Int (AIDeformStyle) ,\n%_;\n%_\n%_9 () XW\nu\n{drawn}U\n9 () XW\n(Adobe Deform Plugin) 1 0 0 XP\n",
hidden(&format!("u\n{shape}U\n")),
hidden(&format!("/ArtDictionary :\n{keys}")),
hidden(&format!("u\n{}{after}U\n9 () XW\n", text_object(story))),
hidden(&format!("u\n{contents}U\n9 () XW\n")),
)
}
@@ -6556,6 +6562,86 @@ fn a_warp_of_type_opens_as_a_mesh_on_its_saved_grid_and_keeps_its_shape_when_its
}
}
/// In the layers, type from the text document made a clipping mask (a clipping group with no
/// clipping path, the type last) clips the group's art as the page draws it: the type comes in as
/// the group's clipping path, editable, and the art doesn't paint past it.
#[test]
fn type_made_a_clipping_mask_clips_its_group_in_the_layers() {
use vectorcraft_doc::live::{EnvelopeKind, EnvelopeOptions, envelope_content_bounds};
let Some(family) = installed_family() else { return };
let doc = type_envelope_text(&family, None);
// The page: the type's glyphs in the yellow of the square they clip, which covers the page, and
// drawn through a flat mesh over their box, which leaves them where they are.
let mut yellow = made_envelope_type(&type_envelope_text(&family, Some("/0 << /0 2 /1 [ 1.0 0.0 0.0 1.0 0.0 ] >>")));
yellow.visible = true;
let content = vec![std::sync::Arc::new(yellow)];
let g = envelope_content_bounds(&content).unwrap();
let points = vec![kurbo::Point::new(g.x0, g.y0), kurbo::Point::new(g.x1, g.y0), kurbo::Point::new(g.x0, g.y1), kurbo::Point::new(g.x1, g.y1)];
let kind = Box::new(EnvelopeKind::Mesh { rows: 1, cols: 1, points, handles: vec![[kurbo::Vec2::ZERO; 4]; 4] });
let options = EnvelopeOptions::NEW;
let flat = Node::new(
vectorcraft_doc::NodeId(1_000_000),
NodeKind::Envelope { content, kind, fidelity: 50.0, editing: false, options, frame: Box::default() },
);
let (_, page) = drawn_envelope(&flat);
let clipped = format!("q\n0 0 1 0 k\n0 0 m\n100 0 L\n100 100 L\n0 100 L\nf\n{}Q\n", text_object(0));
let art = native_with_text(&layer("Art", true, &clipped), &doc);
let r = import(&eps(&page, &art)).unwrap();
// The layers are used, none of their art replaced with the page's (the note on how the type
// differs from the page is about the edges of its glyphs).
assert_eq!(names(&r.document), ["Art"], "{:?}", r.warnings);
assert!(!r.warnings.iter().any(|w| w.contains("came in as its art") || w.contains("weren't read")), "{:?}", r.warnings);
let children = r.document.layers[0].children().unwrap();
let [group] = children.as_slice() else { panic!("{children:#?}") };
let NodeKind::Group { children, clip: true } = &group.kind else { panic!("not clipped: {group:#?}") };
let (NodeKind::Text(t), NodeKind::Path { .. }) = (&children[0].kind, &children[1].kind) else { panic!("{children:#?}") };
assert_eq!(t.plain_text(), "FLUX");
}
/// Type made a clipping mask in an envelope's contents (a clipping group with no clipping path, the
/// type last) clips the art under it there, as the drawn art shows: the envelope opens live, its
/// type editable as the group's clipping path. The art it clips covers the type's glyphs and stays
/// inside their box, so the envelope maps from that box however the art past the type would count.
#[test]
fn an_envelope_whose_type_clips_its_contents_opens_live_with_the_type_clipping_them() {
let Some(family) = installed_family() else { return };
let doc = type_envelope_text(&family, None);
// What it draws: the type in the yellow of the square it clips, which covers it.
let yellow = made_envelope_type(&type_envelope_text(&family, Some("/0 << /0 2 /1 [ 1.0 0.0 0.0 1.0 0.0 ] >>")));
let shaped = |text: Node| {
let mut text = text;
text.visible = true;
let options = vectorcraft_doc::live::EnvelopeOptions::NEW;
let content = vec![std::sync::Arc::new(text)];
Node::new(
vectorcraft_doc::NodeId(1_000_000),
NodeKind::Envelope { content, kind: Box::new(rising_kind()), fidelity: 50.0, editing: false, options, frame: Box::default() },
)
};
let glyphs = vectorcraft_doc::live::envelope_content_bounds(&[std::sync::Arc::new(yellow.clone())]).unwrap();
let (drawn, page) = drawn_envelope(&shaped(yellow));
// A yellow square over the glyphs' box, just inside it.
let (x0, y0) = to_art(kurbo::Point::new(glyphs.x0 + 0.01, glyphs.y1 - 0.01));
let (x1, y1) = to_art(kurbo::Point::new(glyphs.x1 - 0.01, glyphs.y0 + 0.01));
let contents = format!("q\n0 0 1 0 k\n{x0} {y0} m\n{x1} {y0} L\n{x1} {y1} L\n{x0} {y1} L\nf\n{}Q\n", text_object(0));
let envelope = type_envelope_holding(&arc_keys(0.3), &rising_grid(), &contents, &drawn);
let art = native_with_text(&layer("Art", true, &format!("{}\n{envelope}", square(10, 10))), &doc);
let r = import(&eps(&format!("{}\n{page}", page_square(10, 10)), &art)).unwrap();
assert_eq!(names(&r.document), ["Art"], "{:?}", r.warnings);
assert!(super::tests::program_warnings(&r.warnings).is_empty(), "{:?}", r.warnings);
let mut live = vec![];
r.document.walk(|n| {
if let NodeKind::Envelope { content, .. } = &n.kind {
live.push(content.clone());
}
});
let [content] = live.as_slice() else { panic!("{:?}", r.warnings) };
let [group] = content.as_slice() else { panic!("{content:#?}") };
let NodeKind::Group { children, clip: true } = &group.kind else { panic!("not clipped: {group:#?}") };
let (NodeKind::Text(t), NodeKind::Path { .. }) = (&children[0].kind, &children[1].kind) else { panic!("{children:#?}") };
assert_eq!(t.plain_text(), "FLUX");
}
/// A warp of stroked type with Distort Appearance whose drawn art maps the type's bounds with its
/// strokes onto the grid the file saves (not its glyphs' bounds alone) opens live as a mesh envelope
/// mapping from that box (#3179). The drawn art strokes the bent outlines at the stroke's own weight,
+3 -2
View File
@@ -1,6 +1,6 @@
# File format parity
> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-15 · **Change:** minor (PDF import: stroked type keeps the line cap, line join and miter limit the file strokes it with, not butt caps and miter joins, #7741; `.ai` and EPS import: in layers that don't draw as the page, art that differs away from an envelope of type no longer costs it its editable type; it keeps its drawn art where, in the pixels it and its drawn art ink, the layers with it differ from the page more than its own check allows, or past the envelopes' share of the page check, #7141; `.ai` and EPS import: a top-object envelope whose mesh saves its sides' curves in pieces draws its contents along each whole curve, as its drawn art does, #7097; previously: PDF import: glyphs in a span with an empty ActualText come in as outlines, #6971; scores and estimates unchanged; previously: `.ai` and EPS import: type from the text document, type a PostScript program sets and legacy `.ai` type are set in an installed face of their font's PostScript name, exact name first, in the version a text document's record keeps; the `.ai` save writes a static font's version when its name alone gives another copy, #6983; `.ai` and EPS import: type keeps the manual kerning of its text document, #6899; `.ai` and EPS import: type in an envelope with Distort Appearance is also tried mapped from the box of what it paints, its strokes' miter tips and strokes a Transform effect moves included, after its glyphs grown by half its strokes' weight, #6824; `.ai` and EPS import: type filled or stroked with a pattern swatch keeps its pattern, from the art style its text document paint names, #6856; #6865: explicitly requested oversized editing artboard; PDF import: Indic type keeps its marks on their line, and a line whose type would not draw as the file does keeps the file's glyphs as outlines, #5235; previously: newly imported SVG/SVGZ titles are filtered and bounded without changing restored titles, #3626; `.ai` and EPS import, and what every export and `.ai` save draw: type's strokes in an envelope paint at their own weight along its bent outlines, Distort Appearance on or off, #6644; `.ai` and EPS import: centred and right-aligned lines of tracked type are aligned without the tracking after their last character, as the file's page aligns them, #6610; `.ai` and EPS import: an envelope saved in Edit Contents whose mesh lies away from its drawn art by a move opens live on that art, #6570; `.ai` save and open: layer colour presets Yellow, Magenta and Cyan keep their colour, as the `Lb` colour index now follows the file's numbering, #6502; `.ai` save: stroked type keeps its stroke's cap, join and miter limit in the text document, #6472; `.ai` and EPS import, PDF import: tracking and manual kerning in horizontally scaled type take the Horizontal Scale, as the file's page spaces such type; `.ai` and EPS import: stroked type in an envelope maps from its glyphs grown by half its stroke, #3179; `.ai` and EPS import: warps of type open as mesh envelopes on their saved grid, #3179; `.ai` and EPS import: stroked type keeps its stroke's cap, join and miter limit from the text document, #6472; `.ai` save: type in a variable font's named instance names its design-space setting, #6388; `.ai` and EPS import: envelopes of type open live where they draw as their drawn art and the layers with them draw as the page, #3179; `.ai` and EPS import: a note for type in an envelope, #3179; `.ai` and EPS import: the live envelope and warped type check sees white art; PDF import: DeviceN images of one ink or of process plates keep their inks, #6348; `.ai` import: images in a spot ink's Separation space keep their ink, #6350; PDF import: Separation images keep their ink, #6314; PDF editable import preserves authored ActualText once, including empty/nested spans and authored ordering (#6165); cross-line/style layout remains approximate; scores and estimates unchanged; PDF marked-text export (#6309): compatible glyphs stay on one layout line with per-glyph offsets; scores and estimates unchanged; PDF import: image masks open colorized by the color they are painted in, #6313; EPS and `.ai` editing data: a ligature the page names by a private-use glyph matches its text object; EPS import: CIDFonts only named, over a Unicode CMap, set as live type; EPS import: CMap mappings to base-font codes and glyph names; EPS import: CID-keyed fonts in FontSets (CFF) draw their glyphs; EPS import: `kshow` procedures kern live type; EPS import: embedded Type 1 fonts' glyphs and widths; EPS import: CID-keyed fonts draw their glyphs; EPS import: Type 42 fonts' characters and widths from the font they carry, show operators' spacing kept as tracking; EPS import: an image decoder's own buffers stop counting against the memory budget once it is decoded; EPS import: sampled functions interpolate between their samples; `.ai` and EPS type from the text document keeps its tab stops; it keeps auto leading and hyphenation optionLine truncated
> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-16 · **Change:** minor (`.ai` and EPS import: type from the text document that a file makes a clipping mask clips its clipping group, #8106; previously: PDF import: stroked type keeps the line cap, line join and miter limit the file strokes it with, not butt caps and miter joins, #7741; `.ai` and EPS import: in layers that don't draw as the page, art that differs away from an envelope of type no longer costs it its editable type; it keeps its drawn art where, in the pixels it and its drawn art ink, the layers with it differ from the page more than its own check allows, or past the envelopes' share of the page check, #7141; `.ai` and EPS import: a top-object envelope whose mesh saves its sides' curves in pieces draws its contents along each whole curve, as its drawn art does, #7097; previously: PDF import: glyphs in a span with an empty ActualText come in as outlines, #6971; scores and estimates unchanged; previously: `.ai` and EPS import: type from the text document, type a PostScript program sets and legacy `.ai` type are set in an installed face of their font's PostScript name, exact name first, in the version a text document's record keeps; the `.ai` save writes a static font's version when its name alone gives another copy, #6983; `.ai` and EPS import: type keeps the manual kerning of its text document, #6899; `.ai` and EPS import: type in an envelope with Distort Appearance is also tried mapped from the box of what it paints, its strokes' miter tips and strokes a Transform effect moves included, after its glyphs grown by half its strokes' weight, #6824; `.ai` and EPS import: type filled or stroked with a pattern swatch keeps its pattern, from the art style its text document paint names, #6856; #6865: explicitly requested oversized editing artboard; PDF import: Indic type keeps its marks on their line, and a line whose type would not draw as the file does keeps the file's glyphs as outlines, #5235; previously: newly imported SVG/SVGZ titles are filtered and bounded without changing restored titles, #3626; `.ai` and EPS import, and what every export and `.ai` save draw: type's strokes in an envelope paint at their own weight along its bent outlines, Distort Appearance on or off, #6644; `.ai` and EPS import: centred and right-aligned lines of tracked type are aligned without the tracking after their last character, as the file's page aligns them, #6610; `.ai` and EPS import: an envelope saved in Edit Contents whose mesh lies away from its drawn art by a move opens live on that art, #6570; `.ai` save and open: layer colour presets Yellow, Magenta and Cyan keep their colour, as the `Lb` colour index now follows the file's numbering, #6502; `.ai` save: stroked type keeps its stroke's cap, join and miter limit in the text document, #6472; `.ai` and EPS import, PDF import: tracking and manual kerning in horizontally scaled type take the Horizontal Scale, as the file's page spaces such type; `.ai` and EPS import: stroked type in an envelope maps from its glyphs grown by half its stroke, #3179; `.ai` and EPS import: warps of type open as mesh envelopes on their saved grid, #3179; `.ai` and EPS import: stroked type keeps its stroke's cap, join and miter limit from the text document, #6472; `.ai` save: type in a variable font's named instance names its design-space setting, #6388; `.ai` and EPS import: envelopes of type open live where they draw as their drawn art and the layers with them draw as the page, #3179; `.ai` and EPS import: a note for type in an envelope, #3179; `.ai` and EPS import: the live envelope and warped type check sees white art; PDF import: DeviceN images of one ink or of process plates keep their inks, #6348; `.ai` import: images in a spot ink's Separation space keep their ink, #6350; PDF import: Separation images keep their ink, #6314; PDF editable import preserves authored ActualText once, including empty/nested spans and authored ordering (#6165); cross-line/style layout remains approximate; scores and estimates unchanged; PDF marked-text export (#6309): compatible glyphs stay on one layout line with per-glyph offsets; scores and estimates unchanged; PDF import: image masks open colorized by the color they are painted in, #6313; EPS and `.ai` editing data: a ligature the page names by a private-use glyph matches its text object; EPS import: CIDFonts only named, over a Unicode CMap, set as live type; EPS import: CMap mappings to base-font codes and glyph names; EPS import: CID-keyed fonts in FontSets (CFF) draw their glyphs; EPS import: `kshow` procedures kern live type; EPS import: embedded Type 1 fonts' glyphs and widths; EPS import: CID-keyed fonts draw their glyphs; EPS import: Type 42 fonts' characters and widths from the font they carry, show operators' spacing kept as tracking; EPS import: an image decoder's own buffers stop counting against the memory budget once it is decoded; EPS import: sampled functions interpolate bLine truncated
>
> Oversized artboard import update (2026-11-12): Explicit editing-data import retains a single artboard beyond a capped 14,400 pt PDF page (#6865).
@@ -288,7 +288,7 @@ private editing data. VectorCraft:
### Illustrator's private editing data
The app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; a filled clipping path keeps its fill, which paints under the art it clips, except the path of a mask that covers several layers, whose fill is read as a path of its own in the layer that holds the mask's path, and a compound clipping path whose subpaths paint differently, whose filled subpaths are read as a compound path of their own under the art it clips; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, placed PDF and `.ai` pages as placed documents of the [page and Crop to box](https://helpx.adobe.com/illustrator/desktop/add-and-import-files/import-other-file-types/adobe-pdf-placement-options.html) their dictionary names (`AI11 PlacedPDFPageIndex`, `AI11 PlacedPDFCropTo`; a value VectorCraft doesn't read, or a binding to an image variable, leaves a linked image), guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile on a Stroke Offset stroke or written as each side's widths) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing), Pucker & Bloat at 0 or Bas Relief (read from its settings block: [raster effects reference](https://helpx.adobe.com/illustrator/desktop/special-effects-styles/apply-filter-effects/raster-effects-reference.html), [layered image file format specification](https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/), [scripting the filter gallery](https://community.adobe.com/questions-712/scripting-support-for-the-filter-gallery-1064646)) comes in as itself withLine truncated
The app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; a filled clipping path keeps its fill, which paints under the art it clips, except the path of a mask that covers several layers, whose fill is read as a path of its own in the layer that holds the mask's path, and a compound clipping path whose subpaths paint differently, whose filled subpaths are read as a compound path of their own under the art it clips; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789; type from the text document that a clipping group ends with, in a clipping group with no clipping path (`q` … `Q` with no `W`), is that group's clipping path once its text object holds that type alone, as a clipping mask of type is written; where it holds more, or nothing, the group comes in unclipped as before; VectorCraft's own reader rule, learned from saved files), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, placed PDF and `.ai` pages as placed documents of the [page and Crop to box](https://helpx.adobe.com/illustrator/desktop/add-and-import-files/import-other-file-types/adobe-pdf-placement-options.html) their dictionary names (`AI11 PlacedPDFPageIndex`, `AI11 PlacedPDFCropTo`; a value VectorCraft doesn't read, or a binding to an image variable, leaves a linked image), guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile on a Stroke Offset stroke or written as each side's widths) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing), Pucker & Bloat at 0 or Bas Relief (read from its settings block: [raster effects reference](Line truncated
A run of type in the editing data whose baseline direction is 1 opens with Standard Vertical Roman Alignment (https://helpx.adobe.com/illustrator/using/formatting-asian-characters.html) on, which is VectorCraft's own mapping: its half-width characters stand upright in vertical type, and horizontal type keeps the mark with no change to its layout. A run whose baseline direction is 2 or 3 (Tate-chu-yoko), or that names none in the run, its character style or the document's defaults, opens with it off. The scripting reference lists 1, 2 and 3 as the Standard, vertical rotated and Tate-chu-yoko baseline directions (https://web.archive.org/web/20170621180804/https://wwwimages.adobe.com/content/dam/Adobe/en/devnet/illustrator/sdk/CC2015_3/Illustrator%20VBScript%20Reference.pdf, page 256).
A Scatter brush in the editing data whose last 15 numbers start with 1 comes into the Brushes panel in Tints. Each brush art section is read without its frame: an unnamed, unpainted rectangle with no settings of its own at the art's bounds (within 1/1000 pt), closed, or open with its first corner again at the end. A wider frame stays in the art, and an art group with a state or look of its own (hidden, locked, isolated, knockout, an opacity, a blend mode, a name, a mask, a note or an appearance) stays a group.
@@ -361,6 +361,7 @@ Stop opacity on translated artboards remains outside this regression coverage.
| Date | Change | Summary |
|---|---|---|
| 2026-11-16 | minor | `.ai` and EPS import (#8106): type from the text document made a clipping mask clips the art of its clipping group. Illustrator writes such a group as a clipping group (`q` … `Q`) with no clipping path (`W`) whose last object is the text object; the reader now keeps that group, and once the text object holds its type alone, the type moves to the front as the group's clipping path, in the layers and in an envelope's contents. Before, the group came in unclipped, its art painting outside the letters. A slot left empty or filled with several objects (type and strokes the page draws round it) leaves the group unclipped as before. Such type is never weighed as type the page doesn't draw. VectorCraft's own reader rule, learned from saved files (tests `type_that_ends_a_clipping_group_without_a_clipping_path_clips_it` in `crates/eps/src/import/ai/tests.rs`, `type_made_a_clipping_mask_clips_its_group_in_the_layers` and `an_envelope_whose_type_clips_its_contents_opens_live_with_the_type_clipping_them` in `crates/eps/src/import/tests_native.rs`). |
| 2026-11-15 | minor | PDF import: stroked type (text rendering modes 1, 2, 5 and 6, and glyphs under `ActualText`) came in with butt caps, miter joins and a miter limit of 10 whatever the file stroked it with, while paths kept the graphics state's. The characters' stroke now takes the line cap (`J`), line join (`j`) and miter limit (`M`) of the graphics state, as a path's stroke does, and glyphs stroked with other ones start a run of their own, also a glyph filled and then stroked otherwise than the run its fill joined, so the glyphs before it keep their stroke (#7741). Test `imported_stroked_type_keeps_the_files_cap_join_and_miter_limit` in `crates/pdf/src/tests/textstroke.rs`. Scores and estimates unchanged. |
| 2026-11-13 | minor | `.ai` and EPS import: layers that don't draw as the page, even with the drawn art of every live envelope put back, no longer put back the drawn art of every envelope of type. Each live envelope of type is weighed in the page check's own drawing of the pages it lies on, on the pixels that it and its drawn art ink there (the two drawn together on a layer of their own, without the rest of the layers; a pixel inks with an alpha above 8 of 255): it keeps its drawn art and its type, hidden, with the note, where the layers with it differ from the page in more of those pixels than its own check allows against its drawn art (10% of them, or 3% differing with all their neighbours, away from type), or where the envelopes of type that stay live, in the order they were read, would together differ there in more of a page than half of what the page check allows (a budget of the same size as the one their own checks share, kept apart from it). Art that differs elsewhere on the page no longer costs them their editable type; art that differs on their pixels still does. An envelope of type that a clip group or a clipping sublayer clips, an opacity mask masks, or a group with an appearance of its own, another envelope, a repeat or a blend holds keeps its drawn art as before, wherever it lies: drawn on its own it would be weighed elsewhere than it draws, and what holds it can draw it onto the page from off it. An envelope on no page stays live, as the page check doesn't see it, unless the page holds all the art that prints (an EPS's page that is its art's box, where art past the page is compared too): there one reaching past the page keeps its drawn art. Past 12 of them on the pages, all keep it. This holds where the editing data is trusted, where the objects that differ come in as the page's art (the placed files' other placement weighed on its own, as it draws them elsewhere under or over the envelopes; layers that draw as the page with only the envelopes the page holds put back are used as they are; where none of the objects that differ can then come in as the page's art, because an object holds type, the drawn art of every envelope of type is put back and that is tried again, as before), and for a `.ai` whose layers would open alone, which still opens alone: its envelopes of type are all settled again as they were with the page, in the same order and with the same checks, so each that opens live draws as it was weighed, and those the page held get their drawn art back. Where putting the drawn art of every live envelope back makes the layers draw as the page, it is still put back (#5065). In 224 users' files (used locally, never committed): envelopes of type that open live go from 174 to 186, in 8 files, none fewer in any file; no file changes between its layers and its PDF part; 7 renders change, by at most 0.7% of their pixels at 40 ppi (1 closer to the page, 1 alike, 5 further, by at most 0.7 of a percentage point, where VectorCraft's own envelope draws a little apart from the drawn art, within its check); the note for type in an envelope goes from 6 files. Of the 14 envelopes of type that had opened live and lost it to the page check, 2 keep their drawn art: one where the page draws something else where it is, and one in a file that comes in as its PDF part (#7141). Tests `build::candidate_tests::the_page_holds_back_only_envelopes_of_type_where_it_differs_from_them`, `envelopes_of_type_stay_live_within_half_of_what_the_page_check_allows`, `an_envelope_of_type_differing_in_more_of_its_pixels_than_its_check_allows_is_held_back`, `envelopes_of_type_the_layers_dont_draw_in_place_are_held_back`, `on_a_page_that_holds_all_the_art_an_envelope_of_type_past_it_is_held_back`, `objects_come_in_as_the_page_art_with_every_envelope_of_type_put_back_where_a_live_one_holds_a_difference`, `tests_native::layers_that_would_open_alone_keep_an_envelope_of_type_live_where_other_art_differs_from_the_page`, `layers_that_would_open_alone_keep_live_only_the_envelopes_of_type_the_page_doesnt_hold`, `trusted_layers_that_would_open_alone_open_alone_with_an_envelope_of_type_the_page_doesnt_hold_live`, `layers_with_objects_that_come_in_as_the_page_art_keep_an_envelope_of_type_that_draws_as_the_page_live`, `trusted_layers_keep_an_envelope_of_type_live_where_other_art_differs_from_the_page`, `trusted_layers_leave_an_envelope_of_type_the_page_draws_otherwise_its_drawn_art`, `build::candidate_tests::the_other_placement_of_placed_files_is_weighed_on_its_own`, `layers_that_draw_as_the_page_with_the_held_envelopes_of_type_put_back_are_used_so` |
| 2026-11-13 | minor | PDF import: glyphs inside a marked-content span with an empty `ActualText` come in as outlines in their fill and stroke instead of being left out, adding no text (#6971; `empty_actual_text_keeps_the_glyphs_art` in `crates/pdf/src/tests/actual_text.rs`). Scores and estimates unchanged. |
+2 -1
View File
@@ -1,6 +1,6 @@
# Parity with Adobe Illustrator
> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-16 · **Change:** minor (Layers panel: Alt over the list shows the copy cursor while rows or the selection square are dragged, #8217; scores and estimates unchanged; previously: Gradient panel: the add-stop strip under the ramp shows the white arrow with a plus on Windows and X11, #8241; scores and estimates unchanged; previously: Properties panel: the Character section shows the font of the Type tool's selection, not the first run's (#8189); scores and estimates unchanged; previously: Recolor Artwork follow-up (#8031, remaining #4028): native Lab input, picker swatch libraries and Assign-row menus; UI interaction regression coverage; scores and estimates unchanged; previously: #8005: the Color spectrum fills a resized panel; scores and estimates unchanged; previously: Paragraph composers (#4935): the Paragraph panel menu and paragraph styles offer four composers, the Middle Eastern & South Asian Single-line and Every-line (how all type is set, and the default) and a Standard Single-line and Every-line that set Indic, Arabic and Hebrew type glyph by glyph as the font maps it, for legacy fonts that keep a script on Latin character codes; PDF import: stroked type keeps the line cap, line join and miter limit the file strokes it with, a glyph stroked otherwise than the run it joins coming in as a run of its own, #7741; G5: Neon & Glow joins built-in graphic style libraries (Cyan Neon, Magenta Laser, Amber Tube, Electric Lime, Pulse Violet, Cobalt Phosphor); scores and estimates unchanged; previously: Pencil ignores Smart Guides and Snap to Point and shows no Smart Guides, #7252; previously: Pencil continuation, straight-line and closing cursors; scores and estimates unchanged; previously: G5: Weather Icons joins built-in symbol libraries (Sun, Moon, Cloud, Rain, Thunder, Snow); scores and estimates unchanged; previously: a closed Pencil stroke closes with a straight segment; previously: Snap to Point with Smart Guides off draws no Smart Guides labels or lines, #7250; previously: 3D: the seams of Extrude & Bevel, Inflate and Rotate under a white light, and of the faces of Extrude & Bevel (Classic), Revolve (Classic) and Rotate (Classic), went from miter to round joins, so white-light 3D output is expected to differ from the 2026-10-17 comparison at facet corners (not measured: the scenes were not exported again); previously: `.ai` and EPS import: in layers that don't draw as the page, art that differs away from an envelope of type no longer costs it its editable type; it keeps its drawn art where, in the pixels it and its drawn art ink, the layers with it differ from the page more than its own check allows, or past the envelopes' share of the page check, #7141; Character panel: the Set Font Height Reference dropdown shows an icon before each reference, #6304; scores and estimates unchanged; previously: Envelopes: a top object's side whose pieces are all one curve split at anchors follows that curve's parameter, so a top object saved with its sides' curves in pieces draws as its `.ai` drawn art, #7097; scores and estimates unchanged; previously: Graphic Styles list fills a taller panel, #2992; scores and estimates unchanged; previously: PDF import: glyphs in a span with an empty ActualText come in as outlines, #6971; scores and estimates unchanged; previously: library panels' lists fill a taller panel, #2992; scores and estimates unchanged; previously: Swatches list fills a taller panel, #1638; scores and estimates unchanged; previously minor: Object › Rasterize with the Grayscale or Bitmap colour model makes a grayscale image, #6969; scores and estimates unchanged; previously minor: `.ai` and EPS import: type in an envelope with Distort Appearance is also tried mapped from the box of what it paints, miter tips and moved strokes included, after its glyphs grown by half its strokes' weight (#6824; #6617: Swatches panel menu: Show Recent Colors; scores unchanged; previously minor: icon-strip flyouts also resize from the top edge and the canvas-side top corner, keeping the moved top in workspaces (storytold/craft-libs#1094); scores and estimates unchanged; previously: #6865: explicitly requested oversized editing artboard; macOS: the canvas cursor stays after the pointer moves, #6362; scores and estimates unchanged; previously minor: Type tool: kerning at a caret at the start of a line moves the character after it, #5111; scores and estimates unchanged; previously minor: Rulers: the zero point dragged out of the rulers' corner snaps as a drawn point does; previously minor: Live Paint Bucket fills faces crossed in one drag (#6373); previously: #6404: transform-aware Eyedropper character copying; scores and estimates unchanged; previously: Envelopes: with Distort Appearance, type's strokes paint along the bent glyph outlines at their own weight, as users' `.ai` files draw them, which changes how VectorCraft's own envelopes of stroked type draw (#6644; scLine truncated
> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-16 · **Change:** minor (#8106: `.ai` and EPS import: type made a clipping mask clips the art of its clipping group; scores and estimates unchanged; previously: Layers panel: Alt over the list shows the copy cursor while rows or the selection square are dragged, #8217; scores and estimates unchanged; previously: Gradient panel: the add-stop strip under the ramp shows the white arrow with a plus on Windows and X11, #8241; scores and estimates unchanged; previously: Properties panel: the Character section shows the font of the Type tool's selection, not the first run's (#8189); scores and estimates unchanged; previously: Recolor Artwork follow-up (#8031, remaining #4028): native Lab input, picker swatch libraries and Assign-row menus; UI interaction regression coverage; scores and estimates unchanged; previously: #8005: the Color spectrum fills a resized panel; scores and estimates unchanged; previously: Paragraph composers (#4935): the Paragraph panel menu and paragraph styles offer four composers, the Middle Eastern & South Asian Single-line and Every-line (how all type is set, and the default) and a Standard Single-line and Every-line that set Indic, Arabic and Hebrew type glyph by glyph as the font maps it, for legacy fonts that keep a script on Latin character codes; PDF import: stroked type keeps the line cap, line join and miter limit the file strokes it with, a glyph stroked otherwise than the run it joins coming in as a run of its own, #7741; G5: Neon & Glow joins built-in graphic style libraries (Cyan Neon, Magenta Laser, Amber Tube, Electric Lime, Pulse Violet, Cobalt Phosphor); scores and estimates unchanged; previously: Pencil ignores Smart Guides and Snap to Point and shows no Smart Guides, #7252; previously: Pencil continuation, straight-line and closing cursors; scores and estimates unchanged; previously: G5: Weather Icons joins built-in symbol libraries (Sun, Moon, Cloud, Rain, Thunder, Snow); scores and estimates unchanged; previously: a closed Pencil stroke closes with a straight segment; previously: Snap to Point with Smart Guides off draws no Smart Guides labels or lines, #7250; previously: 3D: the seams of Extrude & Bevel, Inflate and Rotate under a white light, and of the faces of Extrude & Bevel (Classic), Revolve (Classic) and Rotate (Classic), went from miter to round joins, so white-light 3D output is expected to differ from the 2026-10-17 comparison at facet corners (not measured: the scenes were not exported again); previously: `.ai` and EPS import: in layers that don't draw as the page, art that differs away from an envelope of type no longer costs it its editable type; it keeps its drawn art where, in the pixels it and its drawn art ink, the layers with it differ from the page more than its own check allows, or past the envelopes' share of the page check, #7141; Character panel: the Set Font Height Reference dropdown shows an icon before each reference, #6304; scores and estimates unchanged; previously: Envelopes: a top object's side whose pieces are all one curve split at anchors follows that curve's parameter, so a top object saved with its sides' curves in pieces draws as its `.ai` drawn art, #7097; scores and estimates unchanged; previously: Graphic Styles list fills a taller panel, #2992; scores and estimates unchanged; previously: PDF import: glyphs in a span with an empty ActualText come in as outlines, #6971; scores and estimates unchanged; previously: library panels' lists fill a taller panel, #2992; scores and estimates unchanged; previously: Swatches list fills a taller panel, #1638; scores and estimates unchanged; previously minor: Object › Rasterize with the Grayscale or Bitmap colour model makes a grayscale image, #6969; scores and estimates unchanged; previously minor: `.ai` and EPS import: type in an envelope with Distort Appearance is also tried mapped from the box of what it paints, miter tips and moved strokes included, after its glyphs grown by half its strokes' weight (#6824; #6617: Swatches panel menu: Show Recent Colors; scores unchanged; previously minor: icon-strip flyouts also resize from the top edge and the canvas-side top corner, keeping the moved top in workspaces (storytold/craft-libs#1094); scores and estimates unchanged; previously: #6865: explicitly requested oversized editing artboard; macOS: the canvas cursor stays after the pointer moves, #6362; scores and estimates unchanged; previously minor: Type tool: kerning at a caret at the start of a line moves the character after it, #5111; scores and estimates unchanged; previously minor: Rulers: the zero point dragged out of the rulers' corner snaps as a drawn point does; previously minor: Live Paint Bucket fills faces crossed in one drag (#6373); previously: #6404: transform-aware Eyedropper character copying; scores and estimates unchanged; previously: Envelopes: with Distort Appearance, type's strokes paint along the bent glyph outlLine truncated
>
> Tech Circuit update (2026-11-14): three original procedural brushes; ten built-in brush libraries (G5).
>
@@ -61,6 +61,7 @@ Artboard Options forwards the active Artboard tool's Scale Artwork with Artboard
| Date | Change | Summary |
|---|---|---|
| 2026-11-16 | minor | `.ai` and EPS import (#8106): type from the text document made a clipping mask (a clipping group with no clipping path, the text object last) clips the group's art once its text object holds that type alone, in the layers and in envelopes' contents, instead of the art painting outside the letters; scores and estimates unchanged (details in [file-format-parity.md](file-format-parity.md); tests `type_that_ends_a_clipping_group_without_a_clipping_path_clips_it` in `crates/eps/src/import/ai/tests.rs`, `type_made_a_clipping_mask_clips_its_group_in_the_layers` and `an_envelope_whose_type_clips_its_contents_opens_live_with_the_type_clipping_them` in `crates/eps/src/import/tests_native.rs`). |
| 2026-11-16 | minor | Recolor Artwork › Assign: native Lab entry in the Color Picker, swatch libraries access in the picker, and row context menu options (Pick from Swatches, Limit to Library) (#4028); scores and estimates unchanged. |
| 2026-11-15 | minor | PDF import: stroked type (text rendering modes 1, 2, 5 and 6, and glyphs under `ActualText`) keeps the line cap, line join and miter limit of the graphics state it is stroked with, as paths do, instead of butt caps, miter joins and a miter limit of 10; a glyph filled and then stroked otherwise than the run its fill joined comes in as a run of its own, so the glyphs before it keep their stroke (#7741; `imported_stroked_type_keeps_the_files_cap_join_and_miter_limit` in `crates/pdf/src/tests/textstroke.rs`). Scores and estimates unchanged. |
| 2026-11-15 | minor | G5: Neon & Glow joins Shadows and Glows, Outlines and Rules, Hand-Drawn, Textures, Painted and Sketched, Gradient Finishes, Shape Effects, Blends and Transparency, Game HUD and Status Effects as an eleventh built-in graphic style library (Cyan Neon, Magenta Laser, Amber Tube, Electric Lime, Pulse Violet, Cobalt Phosphor; original procedural styles generated in code); area score and estimate unchanged. |