변경 이력

A stroke’s outline is one centreline offset half a width each way, so the fit now keeps a quarter of the stroke’s own width and a hairline band comes back as a band rather than as a line of no area.

One rule ships, in the stroke stage. A stroke outline is one centreline offset half a width each way, and a fit may move any sample by its tolerance — so where the budget was the boundary fitter’s own traced pixel, every sample of BOTH flanks of a band a pixel across sat inside the centreline’s budget, and the optimal polygon was free to draw the centreline and call it the outline: a hairline grid’s lines reached the tracer, were correctly taken as strokes and measured at their own width, and then left it as triangles of no area.

The budget is now a fraction of the stroke’s own width, so each flank keeps half a width of its own room and the outline keeps at least half the area its samples state. Nothing else moved: every stroke the icon, emoji and JPEG corpora draw is wide enough that the budget it already had sits below the new one, so all three trace byte-identically, and the movement is on the large corpus’s hairline grids, whose thinnest lines come back as bands of the width they were measured at.

Measured and refused this round: half a width as the budget, which is the collapse bound itself rather than a margin inside it and leaves three of the six readable lines degenerate; two fifths, which leaves one of them a hooked cubic of no width; every other constant in the stroke stage, measured and found not at fault; and, from the two packages that shipped nothing, four readings of a bevel collapse that may not spend area — one failing the smoke gate, one passing every gate and refused on the per-fixture bar, one too coarse to aim, and one that reaches the flagpole but moves the smoke set by a few bytes — together with a band-run reading of the crest test that admits no blue and makes both codec palettes worse.

A fill is now where the snap settles as well as where the bytes repeat, a component that is one edge’s ramp is that edge’s rim, and a closed fit may not spend the area its samples enclose.

Three rules ship at once, two in the palette stage and one in the curve fitter. The palette had read a fill off the BYTES — a pixel and its neighbours holding one entry’s own values — which is right on flat artwork and wrong on a football’s seams, where the ball’s shading and a codec carry one grey a few levels along until the ramp rule hands every pixel of the seam’s two ends to the white or the pentagon beside it; a fill is now also a place the LABELLING settles, and the seam comes back in one piece from one pentagon to the next.

The sliver pass learns the shape one size up from a strip — a whole component with one label inside it and one outside it all the way round, too wide for the strip pass to have judged it, coloured as a blend of its two neighbours and holding no settled core of its own — and gives each of its pixels back to whichever neighbour that pixel’s own value is nearer. And a closed fit may not spend the area its samples enclose: a curve within a tolerance of a walk cannot differ from that walk’s area by more than the tolerance times the perimeter, so that product is the fitter’s own resolution written as an area, and a face that encloses less than it on samples that enclose more is refitted with every straight run held to the stretch actually detected straight — which gives a chequered flag’s pole edge and a hairline grid’s longest line back.

Measured and refused this round: the settled-fill seed read over four touching pixels instead of an interior cross, which fails the codec corpus’s region gate because a blurred shoulder is confident two or three pixels across; the component reading without its width filter, which re-decides strips the pass before it had already kept; a deeper bar for the settled core, which dissolves a shape the artwork drew; and a chord-within-slack-of-its-own-samples rule, which does not separate the lost strip from a star’s correct extension at all.

An ink whose crests are arranged as a line now survives the dust count, a straight run’s chord may not slide off the line it was detected on, and a bracket that is the edge’s own rim is not a side.

Three rules ship at once — one in the palette stage, one in the sliver pass and one in the curve fitter — and on hairline artwork they compound. The palette now reads how a candidate ink’s crests are ARRANGED, as one hairline or as the few lines a grid partitions into, standing between two fills of a single ground and nobody’s halo, and lets such an ink survive the dust count: a count is a reading of an area, and a line a codec has washed away has none.

The fitter no longer lets a detected straight run’s chord slide sideways off the line it was found on, which is what had carried a hairline lane’s two sides onto one another until the lane enclosed no area at all and was dropped unpainted. And a strip the sliver pass dissolves is no longer handed to a bracket that is the edge’s own rim — the band of ramp values a codec piles up beside an edge until the palette gives it an entry — which is what had grown a nub off the lower edge of a football’s centre pentagon.

Measured and refused this round: asking both ends of the fitted chord to sit on their line, which returns a chequered flag’s pole edge but costs a star its sharpest point on the fitter’s own acceptance set; and the disjoint means floor, rebased onto the rim rule and re-measured over the whole large corpus, which fails its region gate because the shape it must reach is a whole component rather than a strip.

A colour the raster holds level across a line’s worth of its own width is an ink rather than a ramp, so a football’s seams come back on the copy a blur and a codec had taken them from.

A colour the raster holds FLAT is an ink, and a colour it holds only on a slope is a ramp. The palette now walks the pixels a candidate colour is held at, takes each pixel’s own normal from the longest held run through it, and calls that pixel level when the raster holds the pixel’s own value for three samples across — and it draws the candidate when it has a line’s worth of such pixels, which is the run length the ridge reader already uses, at the one place a crest runs between two fills of a single ground.

One fixture of the two hundred and ten in the JPEG corpus moves: a football emoji, blurred and codec-coded, whose seam colour reads sixty level pixels of the hundred and fifty-four it is held at, while every colour the rule must refuse — a rescaled logo’s two ramp shades, the shell around a cloud mark, the light half of a blurred hairline — reads none at all, so the seams come back in their own ink and the palette comes back exact. The corpus figure rises a hair even so, because that fixture now draws far more boundary than it did and its own error, halved, still sits well above the corpus tail; both corpus means fall.

Measured and refused this round: the same reading on a raw bar of one level pixel, which helps the codec-coded football at the smallest size but hurts its plain twin and takes the pooled figure for real artwork the wrong way; a rule letting a hairline’s ink survive the dust count, which draws hairlines that had traced as blank pages and costs one letter a rim of the codec’s own overshoot; and a floor that brings thirteen near-paper palettes back exact, refused because the entry it admits is the value another shape’s anti-aliased rim passes through.

A shape too small for the fixed depth that tells a fill from a codec’s rim is now read by its shape instead, and a halo beside a stroke is refused as the ramp of an ink the residual still holds.

The palette tells a fill from the rim a codec paints beside an edge by how deep the region runs, and no one depth serves both: the reach of a compression block’s overshoot refuses a rounded rectangle sixteen source pixels across, which is why the near-paper shapes came back a colour short at the smallest size. What separates them is the shape of the region rather than its depth — a rim is a band, its area many times the square of its depth because its length is the perimeter of whatever it hugs, while a fill is compact, and no region of any shape can be more compact than a disc — so a region past a ramp and compact is a fill however shallow it is.

The second rule is about a halo: the share-free hairline look that brings a grid of coloured lines back had been held to palettes with nothing but paper in them, because on a palette that already holds a ramp it admitted a codec’s ringing beside a stroke as an ink of its own. A halo is a mixture of its ground and the ink it rings, and while that ink is unadmitted the residual is the only thing that knows it, so the residual is now asked whether one of the heavier clusters it is still holding explains the candidate — and a hairline grid that came back with one line missing and two in the wrong ink now comes back with every line drawn.

Measured and refused this round: reading what a candidate paints on either side of itself, which its own census refutes, because a colour on a ramp between two inks is the nearest colour to every anti-aliased edge in the picture, and which, confined to the run the raster holds, draws a football’s seams but dissolves a hairline outright.

The benchmark had been charging the tracer for authored edges a later shape paints over — seams under a football’s pentagons — so the boundary is now scored twice and gated on what the raster actually shows.

Three of this round’s diagnoses of the worst real artworks landed on the same finding: the ground truth’s boundaries are sampled from every path its author drew, including the ones a later shape paints over, so the score had been charging the tracer for edges the picture it was handed never carried — the seams under a football’s pentagons, the upper sides of a rocket’s first shape under its body, the internal joins of a compound mark whose overlapping pieces are all one black.

The region count has been read two ways for that authoring gap since well before this release, and the boundary now is too: it is pooled once over every authored curve and once over only the curves the artwork’s own render actually shows, and the release gate reads the second. Nothing on the published smoke set is hidden by it, because those shapes do not overlap and the harness measures that rather than assuming it, so every figure on this page is the number it already was.

What the change buys is that the error left on real artwork now names the engine’s own misses rather than the way the truth was drawn: a chequered flag’s lost sliver of light, a rocket’s yellow disc, a football’s seams under a codec. Two candidate rules for the last two were built, measured and refused — one admits a shade of the committed logo it must not, the other draws the seams and dissolves hairline wordmarks — and both point at the same next question: what a candidate colour paints on either side of itself.

A near-paper shape whose colour sits inside the merge distance of its neighbour was folded into it; where the raster holds both as settled fills of its own, the palette now keeps both.

A shape drawn in a tint of its own paper came back in its neighbour’s colour at every size, because the palette folds two colours the eye cannot separate into one — even where the raster has just held both as fills of thousands of pixels each. That bar is load-bearing and stays; what now overrules it is the raster’s own evidence about the pair, asked four ways: two plateaus the reader holds separately, each owning a region with an inside deep enough to be a fill rather than the rim a codec paints beside an edge, standing further apart than the raster’s own noise, on a scan with no compression lattice to have invented the levels in the first place.

The near-paper shapes come back at every size but the smallest, with their region counts exact and one colour still short — the fifth ink sits nearer to the neighbour it is drawn in than a clean scan’s own noise, which is the same gap two readings of one orange have to keep folding at. A hairline on a palette that holds nothing but paper is now asked no share of the canvas at all, because a share is a share of an area and a line has none: a grid of coloured hairlines that traced as an empty sheet comes back drawn, and the look is held to that palette because a codec’s ringing beside a stroke is arranged exactly like the stroke it rang off.

Measured and parked this round: the chequered flag’s lost sliver, whose crests read as the saddles where its chequer crosses, since refusing every one of them moves the fixture by a fraction of what it needs.

The bar that keeps a codec’s overshoot out of the palette is twice the mixing tolerance because it guards a ramp; where the palette holds one colour there is no ramp, so a near-paper hairline keeps its ink.

A hairline drawn in an ink a shade off its own paper was traced as a blank sheet: the sampling cross finds only the paper, the plateau reader finds no plateau, and the one stage that does see the ink refused it against a bar wider than the whole contrast the ink has. That bar is twice the mixing model’s tolerance, and the doubling is there to catch a codec overshooting a ramp — but a ramp runs between two colours, and where the palette holds only the paper there is no ramp for anything to have overshot, so such a crest is now asked the plain tolerance once.

Every uploaded-artwork set comes back byte-identical, and on the large generated corpus the near-paper hairlines that had traced as an empty sheet since it was built come back with their ink, their shapes and, on all but one copy, exactly their own region counts. The cost is named: one small hairline under a codec is drawn a touch fatter, with a ragged top corner.

Measured and held this round: an admission that reads a whole hairline’s crests as one line rather than weighing its ink, which brings back the hairlines the large corpus still loses whole and is refused because a codec-shredded line then traces as many fragments as the codec left it; and a census of the chequered flag’s crests, which finds them all at the crossings of the chequer — saddles rather than strokes — and so rules out the fill readings the last round had named for this one.

The palette now tells a real ink from a codec’s mixture by where its pixels lie rather than by how far apart their colours are, the snap reads a fill map, not a disc, and a bridge stops at a pixel another ink owns.

A stroke leaves its crests along one line, while the halo a codec paints beside a strong edge turns through every direction the outline has a corner for. The palette now reads that arrangement rather than how far the colour sits from the inks it already has, so a purple star that has come back in a mongrel magenta with cyan holes and a pink cross since the corpus existed is solid purple, and the apple every earlier attempt broke keeps its stem.

The rule that decides whether a shade is part of a ramp now reads a map of the colours the raster actually settles at, dilated to the reach the artwork itself asks for, instead of walking a disc: the low-contrast stars come back exact, a football’s and a flag’s thin seams survive, and the snap is faster on every set. Its cost is named — on one blurred JPEG the near-invisible boundary between a flag’s white field and the page is drawn as a long shallow wave, and the measurement says the reach itself is the mechanism.

A bridge across a gap in a hairline is refused wherever it would cross a pixel another ink’s ray explains better, and the instrumentation behind that rule refuted the diagnosis it was built for: the chequered flag has no bridges at all, so the sliver of light it loses is a crest decision, which is where the next round goes along with the second mixture the freed palette slot lets a crowded scene find.

Where two inks are almost the same colour, a crest used to go to whichever it had come furthest toward; it now goes to the one whose ray it lies on, so a star’s tips stop taking the neighbouring star’s blue.

A crest — a pixel on the ridge where a fill meets the paper — used to be given to whichever ink it had come furthest toward from the ground, and where one ink is a shade of another’s ramp to the same paper the two rays are one line, so the shade wins that test at every pixel and two near-identical blue stars each had their spike tips painted in the other’s ink. A crest is a mixture of the ground and one ink, so the ink is now the one whose ray the crest lies on — the least sideways distance from that ray — with the crest’s own ink in the running, because when it wins there is nothing to give back; where two rays sit closer together than the raster’s own rounding, the tie goes to the ink the raster paints as a settled run of its own bytes beside the crest.

Every corpus comes back with fewer stray regions, fewer nodes and smaller files, the low-contrast stars are exact on their clean copies, and the icons, the wordmarks and the logo controls are unchanged to the byte. The cost is named: on a chequered flag whose light field, grey pole and dark squares are nearly collinear, two copies lose a one-pixel hairline of light where a square meets the pole, and undoing the tie that fixes the stars would cost far more than it buys. Measured and refused this round: a fill map that halves the blurred stars but draws a long shallow wave along the near-invisible edge between a flag’s white field and the page, and a palette rule that gives a mongrel star back but loses an apple’s stem.

On a blurred JPEG a colour on the ramp between two others can still be a real ink; the palette now asks whether the raster holds it as a fill with an inside, and the chequered flag’s pole comes back in its own grey.

A colour on the ramp between two others is usually the ramp, and the evidence that says otherwise is the flat plateau the raster holds of it — which is exactly what a codec takes away, so the chequered flag’s grey pole has been painted in the flag’s own pale blue on every build. On a raster that quantizes, and only there, the palette now asks the question the plateau cannot answer: does the colour paint a region deep enough to have an inside, and does it sit far enough from the entry that would otherwise take its pixels for the distance to be the evidence on its own?

The reading only ever admits a colour and never refuses one, and every clean upload is untouched, so a single fixture of the whole benchmark moves and it is the flag: its pole comes back in its own grey, with the highlight down one edge still to find. Measured and refused this round: a palette bar restated in the raster’s own noise, which gives a mongrel star back and breaks the scene beside it; a snap rule that halves two blurred stars and erases the thin seams of a football and a flag; and the rounded rectangle whose side a codec bows, which none of five local readings explains.

The line-and-arc decomposition now keeps the pass that keeps the artwork’s sides, so a rounded rectangle whose corners outrun its sides comes back as four lines and four arcs rather than a bowed squircle.

A rounded rectangle is drawn as straight sides and corner arcs, and the decomposition that finds them refines its breakpoints in passes, each judged against the pieces’ own lines and circles rather than against the outline they finally draw. Where the corner arcs are longer than the sides that join them the two readings disagree: the breaks drift, the shortest side falls under the raster’s own softened corner and is folded away as a bevel, and the shape comes back as free curves with every side bowed. Every pass is now finished into a decomposition and read against the outline it actually draws, and a pass is refused — the pass before it standing — only when it both costs the shape a straight side and leaves a sample well off that outline.

Rounded rectangles and polygons across the large corpus come back with their sides, the small synthetic set is byte-identical once more, and real logos and JPEG uploads land a little closer with every region count unchanged. Held with their patches and their measurements: a run that redraws a blurred letter’s legs but blunts a swoosh’s tip, and a palette rule that solves one mongrel star and costs an emoji its stem.

A single crest that bridges two touching shapes is no longer painted as ink, so Opera’s crescents come apart, and the stroke outline’s corner window is half a width, so thin diagonals fill their outlines.

The crest rescue paints hairline crests back to their ink, and one crest laid across the tangency of Opera’s two crescents welded them into one shape. Two readings now have to agree before a crest is painted — the strict reading must find a crest beside it along its ridge, and the rescue’s own gate chain must certify a neighbour on the raster — so a crest alone on its ridge is a contact between shapes and stays paper; the hairline wordmarks that three earlier rules damaged are byte-identical.

The stroke outline fitted its corners with a window of a whole stroke width, which let one flank run diagonally across a thin band and drew every clean diagonal hairline narrow; the window is half a width now and the five narrow lines fill their outlines with no region moving anywhere. The certified-run rule for Vim’s blurred “m” was measured and refused on Nike’s swoosh, and the snap’s handling of a one-pixel band of ground is pinned by tests after its premise was refuted.

The sliver pass used to dissolve every one-pixel strip a codec or a snap leaves in a shape; a strip that separates two shapes of real size is now kept as the seam the artwork drew.

A snap tears shapes into crumbs joined by one-pixel strips, and the sliver pass exists to dissolve them — but the same pass dissolved the one-pixel paper seam between the bands of Nvidia’s eye, welding two shapes the artwork keeps apart. Three block-shaped rules were measured and refused for it, one on the acceptance logo’s own lens; this release dumped every strip the pass removes on five fixtures first, found each failure firing on a shape-and-a-crumb weld, and states the rule from the strip: kept only where its two sides are comparable shapes of real mass.

Two fixtures of the whole benchmark move and every synthetic one is byte-identical. Held with their patches and measurements: a width reading for thin diagonals that is right while the drawing still shrinks downstream, a lone crest that fuses Opera’s crescents and cannot yet be refused without costing the hairline wordmarks, and the large hairline grid whose remaining inks no rule admits without regressing real artwork.

A block codec’s ringing used to seed its own colour beside every hard edge; it now folds into the colour it rings, a lost diagonal is drawn, and the flattened face count reads the truth by the engine’s own rules.

A JPEG quantizing across a strong edge overshoots the flat colour beside it, and after a blur that rim is wide enough to seed its own palette entry — thirteen near-white ribbons around a letter, a green cast over a whole page. The rim is now recognised by three readings the raster already gives — its distance against the measured ringing amplitude, its weight as a share of the colour it rings, and the absence of any settled core of its own — and folded in, so every PNG stays byte-identical and the letters trace to their exact geometry.

The stroke stage reads a hairline across its own rim and counts a cross-section as a width only where both flanks reached the ground, which draws the diagonal it used to lose without pinching the lines it already drew well. The benchmark’s flattened face count now uses the region tracer’s own containment and cover rules, after which the engine is charged for far less under-segmentation than the old column claimed.

Under a codec a one-pixel line breaks into crumbs the dust pass used to sweep away; crumbs that lie on the crests the ridge reader finds are ink now, and canvases that came back blank return their artwork.

The dust pass judged a colour by absolute pixel counts, which is the right question about a codec’s block and the wrong one about a hairline, whose ink is one source pixel wide however large the page is. It now asks whether the crumbs lie on the crests the ridge reader finds, and keeps them only when their colour is nowhere the palette can make — so every PNG in every corpus is byte-identical, and on the large corpus a diagonal, two stars and a hairline grid that traced to empty paper come back as the artwork.

Two packages are held with their measurements: a stroke reading that recovers a lost diagonal exactly but draws thinner lines pinched, and a study of the flattened region count that found the count itself over-reads where same-colour shapes touch — both resume next round from saved patches.

A hairline whose two sides sit on one ramp is now read against that ramp, so thin strokes come back where they were dropped, and a large canvas no longer refuses ink because the page is big.

Where a crest’s two valley flanks lie on a single ramp, the ridge reader now folds them into one ground — but only as a tail, never as a fill, and only in the second reading, which is where the rule earns its gains without the first reading’s unguarded path to the snap’s rescue. Coca-Cola’s script gets its limbs back, Opera’s thin copies improve, and the real corpus loses an eighth of its region error with every synthetic fixture byte-identical.

The palette’s residual floor is now denominated in the edge population rather than the canvas, so a hairline’s ink on a large page clears a bar that grows with the page’s side, as the ink does; the bar can only fall, so no image loses a colour it had. The benchmark harness also scores the region count against a flattened truth beside the authored one, after an audit found the authored convention flips the reading’s sign on a quarter of the real corpus — the football reads exactly right flat.

On JPEG artwork a pixel on a blurred ramp between two colours now goes to the pair that explains both its flanks, not to a nearby shade — the Swiss cross keeps its edge and the Japanese disc loses its ghosts.

A chroma-subsampled JPEG bows a colour ramp off the straight segment between its two ends, and where a third palette entry sat close to that bow the snap used to hand the ramp’s pixels to it — a paper-coloured rim along the Swiss flag’s white cross, a ring of codec ghosts around the Japanese flag’s disc. The pair whose segment explains both flanks of the pixel now outranks a shade of it, and the rule fires only where the raster’s ramps actually bow and only where the raster does not hold the chosen entry’s own bytes within the flank walk’s reach, so every PNG in every corpus is byte-identical.

The cost is small and named: one blurred low-contrast polygon at the smallest size draws its corners a fraction of a pixel rounder, and one emoji gains a second path of its paper colour that the eye does not find. The hairline reading stays held for a third round with its five candidates saved, and the large corpus’s worst cases turned out to be a share floor measured against the canvas rather than the ink, which is next.

A closed shape no longer ends with a second line back to its start, so the file carries exactly the nodes the artwork has and an editor shows no duplicate anchor.

Every closed path the engine wrote ended with an explicit line back to its first point, and then closed — the same edge twice, which is the duplicate anchor point an editor shows at the start of a traced shape and one extra node on every rectangle, polygon and star. A measurement of where the surplus nodes on the benchmark sets came from found that this convention was all of it on the synthetic set, with every junction already arriving as a single vertex, so the closing line is now implicit. Nothing in the geometry moved; every render is byte-identical.

A second, much larger synthetic corpus is now committed and measured, with more shape kinds, palettes, hairlines and a larger canvas, and its first run names the engine’s weakest cases in order. The converter’s job ticket also reads the visitor’s plan, so a Pro customer no longer sees a free-preview stamp beside their queue.

A thin line is read by its own width and ramp, so a script wordmark or a fine outline traces as one stroke instead of a row of dashes.

A hairline’s colour does not run the way a fill’s does — its coverage wobbles along the stroke with the pixel grid — and the ridge reader had been refusing it wherever the colour test failed, so a script wordmark came back in pieces and a blurred letter dissolved into the paper. Where the first reading refuses, the engine now asks a second in the ridge’s own terms: the pixel must be the deepest of its own cross-section, the run continues along the ridge’s ramp, and the width a couple of pixels along must match — a stroke has a width, a wedge has a rate. A crest that continues across a gap no longer than its own width is one crest, so corners and crossings no longer break a stroke, and a stroke that grows out of a fill of its own ink is one shape with it.

On JPEG input a fill cut into pieces by seams — a football’s body, a flag’s cross — is read as one fill before the palette decides whether it is real, so the body keeps its colour instead of merging into the paper. Pro accounts gained the batch queue in the converter, the site gained this changelog, and the preset table is now checked against the engine’s by a committed golden file.

A shape painted the colour it already sits in is no longer written into the file as an invisible duplicate.

Layered output used to nest a same-coloured face inside the shape around it and write it out as a path of its own — invisible on screen, but a region in the file, with nodes of its own, that an editor finds the moment the shape above it is moved. Those faces are now left out, and so is a face whose fitted outline encloses nothing at all. Icons and logos with large flat fills come back leaner, with every visible shape still described exactly once.

Pro accounts also gained API keys with usage metering on the account page, and the palette editor in the converter.

A logo uploaded small, uploaded large or saved as a JPEG now traces to the same paths, the same nodes and the same colours.

A boundary that runs between two crossings of one circle is now drawn as that circle’s arc, exactly, instead of as a run of short curves hugging the pixels — so the size you upload at no longer decides the shape of the result. On JPEG input, a shade in the middle of a colour ramp is read as the ramp rather than as a third ink, which removes the spurious colours a chroma-subsampled file used to add along its strong edges. PNG uploads also trace faster, because a measurement introduced for JPEG artefacts is now skipped whenever no two colours are close enough for it to matter.

The overshoot a JPEG paints beside a strong edge is folded back into the fill it rang off.

Where two colours sit close together, JPEG compression rings on either side of the edge between them, and the tracer used to paint those rings as thin bands of the neighbouring colour. The engine now measures how far a raster’s edges overshoot their own flanks — nothing at all on a PNG — and dissolves the bands the codec left behind, so a smiley’s teeth or a football’s panels come back as the regions they are. Where the raster held nothing to measure at a junction, the curve leaving it is redrawn from the crossing’s own geometry, so the tip of a lens on a JPEG leaves cleanly instead of with a hook.

The engine reads the EXIF orientation tag itself, so a rotated photo comes out the right way up wherever you trace it.

A phone stores a photo the way its sensor saw it and records the rotation in an EXIF tag, and the engine had been ignoring that tag while browsers honoured it — so the same file could trace upright on the site and sideways through the API or the command line. The tag is now read out of both JPEG and PNG containers and applied before the first pixel is examined, with every transform checked against what Chromium, Firefox and WebKit return for the same files. A file with no tag decodes exactly as it did before, so nothing else in the output moved.

The browser had been colour-managing and clipping wide-gamut PNGs before the engine saw them; it now hands over the stored pixels exactly.

A PNG carrying a wide-gamut colour profile was being converted to sRGB and clipped by the browser’s decoder, which shifted a logo’s reds and oranges and — because every boundary is measured off the anti-aliasing ramp — cost geometry as well as colour. The converter now decodes with colour management and premultiplication off and reads the bitmap back exactly, so the site traces the same bytes the command line and the API do.

On JPEG input, the engine can now tell a codec’s duplicate of an ink — scattered in blocks across one fill — from a genuine second colour with a shape of its own, so the flat regions of a compressed logo come back as single fills again.

A JPEG stores one flat colour as a few nearly identical levels; the palette now reads them as the single ink they are.

Compression quantises each block of a JPEG on its own, so a flat fill arrives as a patchwork of levels a few units apart, and the tracer had been giving each level regions of its own. The engine now measures the lattice a raster holds its colours on — none on a PNG — and merges levels that sit one step apart, so a compressed logo comes back with the inks it was drawn in instead of a duplicate of each.

In cutout output, a hairline stroke is now cut out of the shape it lies on rather than painted over it, so the cutting and embroidery presets no longer produce double-painted areas or gaps along a thin line.

A corner is placed where its two sides actually meet, a thin stroke comes back as a stroke, and JPEG input got a benchmark set of its own.

A raster bevels every sharp corner, so the samples along a star’s point stop short of the tip. Each side of a detected corner is now fitted to its own samples and the vertex placed on their crossing, checked against the depth the raster left out — so a star’s points and a triangle’s apex sit where the artwork put them. A stroke about a pixel wide is traced as a centreline with a width rather than as two ragged edges, wherever that reads better.

The engine also stopped assuming every upload is a clean PNG: it measures the raster’s own noise once and states every threshold in it. That changed nothing on PNG and is what made the JPEG work in the releases that followed possible.

The hole in an O is now part of the O — a second contour wound the other way — instead of a paper-coloured patch painted on top.

A tracer that stacks its output paints a counter as a background-coloured shape over the letter, which is what a designer finds on moving the letter aside in Illustrator. Each counter is now cut as a hole of the shape that has it, in every export format, so a letter can be moved, recoloured or cut as one object.

Corners at small sizes are found on the samples and put back on the crossing of their sides, and a colour the raster holds exactly over a flat area is treated as an ink however close it sits to the blend between two others — so a chequered flag keeps its greys and a football keeps its seams.

A boundary is broken into the straight lines and circular arcs it is made of, each one exact and tangent to the next at the join.

A rounded rectangle now comes back as four lines and four quarter-circle arcs rather than as a run of curves that only approximates them, and a D-shape’s long arc as one exact piece — geometry a cutter follows without stuttering and an editor can adjust by its radius. Low-contrast edges are now read against the raster’s own noise rather than against the pair of colours either side, so a hairline at any angle is traced as one stroke rather than as a row of dashes. Together, those two changes are what make a traced icon open in an editor as a handful of recognisable shapes rather than as a cloud of points.

A hairline earns its own colour, and a pixel in the middle of a blend can no longer claim a third one that is not there.

The palette stage now reads a short profile across each feature once and answers three questions with it: a stroke one pixel wide is a ridge and keeps its colour, a pixel whose profile runs between two colours is not confident about a third, and the coverage across a ridge is handed back to its crest. That is what stopped a blurred wordmark from vanishing and a chequered flag from gaining stripes of a grey it never had.

Every closed boundary is also cut clear of its corners before fitting, so a rectangle keeps all four corners instead of losing one to the point where the tracer happened to start walking.

Every boundary sample is placed from the source’s own anti-aliasing to a fraction of a pixel, and every junction on the crossing of its curves.

The tracer stopped reading edges off the pixel grid: for every boundary it walks the source pixels across the anti-aliasing ramp and places the sample where the coverage says the edge is, which is exact at any sub-pixel position for a clean edge and still exact under blur or enlargement. Where three regions meet, the junction is now solved as the crossing of the arcs and lines that arrive there, so the tip of a lens is the intersection of its two circles rather than a blunt stub a pixel short of it. Discs come back at the radius the artwork drew them.

A boundary that is an arc of a circle comes out as that circle, and a straight run comes out as one line.

The fitter now recognises primitives: a run whose samples stay within tolerance of their chord is one straight segment, and a run a circle explains at least as well as its curves is written as exact arcs of that circle — so a whole circle costs the same few curves whatever size it was uploaded at, and a lens between two discs shares one coincident arc. A sliver pass dissolves the thin strips of a third colour that a two-colour snap leaves where two edges cross, which is what JPEG ringing had been turning into teeth at a lens tip. Junctions that arrive as a cluster of points are merged into one.

The palette no longer invents a colour along an anti-aliased edge, and every boundary is fitted as the fewest straight pieces first and the fewest curves second.

Snapping every pixel to its nearest palette colour used to send the white-to-red edge of a logo to an orange that happened to lie between them, painting a ring around the disc that is not in the artwork. A pixel is now snapped only to a colour that borders it, and two near-identical colours merge on the evidence of their own pixels rather than on distance alone, so a pale field beside white paper survives. Boundaries are then fitted as the optimal polygon before the curves, and runs of smooth curves merge back into one wherever the result still describes the samples, so files come back with fewer nodes and cleaner edges.

Two regions that touch now share one fitted boundary, so stacked layers coincide instead of leaving a rim or a hairline gap — and EPS and DXF export shipped.

Each region’s outline used to be fitted on its own, so two regions that touch were fitted twice from two polygons that disagreed by up to a pixel, and the layer under a disc showed as a rim around it, or as a white gap in cutout mode. Every boundary two regions share is now fitted once and handed to both, reversed where the second runs the other way, so the rim and the gap are gone in every export.

EPS for print workflows and DXF for cutters, plotters and engravers joined SVG and PDF as export formats, and a second benchmark corpus of real icons and emoji was added to keep the engine honest on artwork rather than on synthetic scenes.

The engine fits genuine cubic Bezier curves to every boundary, replacing the chain of short straight pieces that read as a polygon at any zoom.

The week-one tracer’s output was a chain of short straight segments with collinear handles, which looks like a polygon the moment you zoom in and carries several times the nodes an editor wants to see. The new fitter finds the corners, fits least-squares cubics between them and splits at the worst error, with smooth joins everywhere that is not a corner and a tolerance of a quarter of a source pixel. A traced logo now has a fraction of the nodes it had, and its curves are curves.