A braze-casing angle whose 0.98" curve was exported as 199 lines of
0.005" made a single Fill of 33 copies take 8.6 minutes, and Auto Nest's
Irregular engine never finished its first plate in 15 minutes: it
proposes such fills as Lattice blocks.
Two causes. Shape.JoinOffsetLines tested convexity with an unnormalized
cross product, so shallow concave turns between tiny lines fell under
the epsilon, the nearly parallel offsets missed each other, and the
fallback arc swept the long way round: a near circle per joint, 414
entities in the spacing outline. A non-convex turn now gets a straight
bridge, as concave corners already do.
Spacing outlines with a dense run of tiny entities are also thinned to
Douglas-Peucker chords on an offset padded by 0.0015, so every chord
stays outside the true spacing outline: clearance can only grow, by at
most 0.003 beside the run, and validation still reads true geometry.
The angle's outline is now 21 entities; the Fill takes 69 s with no
overlaps, and Irregular finishes the whole job (24 sheets in under 5
minutes, 22 by a 15-minute limit, against 28).
Problem-nest corpus (auto-nest, fill): all layouts and counts unchanged.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The corpus nests' comments were single long paragraphs that were hard to
scan in the comment box; they were rewritten on the server as Setup /
Problem / Fix sections. Describe that layout so new nests follow it.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A part a single tab could hold level kept its outside entry to the points
where the tab steadied it, so the head detoured to them and often left the
part back over itself. Tabs hold most parts wherever they land, a part whose
tab does not is still tabbed and avoided once cut, and the detour costs
every part. Every support-tabbed perimeter now offers each entry clear of
inside corners (plus its best tab point), ranked toward the next cut like an
untabbed part's. Only when none of those fits a lead-in does the search fall
back to every entry, steadiest first.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Long holed strips on a support grid were entered mid-length, and those
resting on a line of contacts beside their center of gravity on the far
side, so the head left back over the strip. Four causes:
- A support tab that cannot hold a part level still led its entries with
the steadiest point. No such entry steadies the part enough to be worth
a detour, so every entry clear of inside corners now ranks toward the
next cut, as for an untabbed part. The part is still tabbed and still
avoided once cut.
- A next part level with this one's center faced the bottom by rounding.
A level target now faces neither side on that axis.
- The tab-retention check measured a lead-in against the start tangent,
so a straight in-line corner lead-in on a tabbed outside, which runs
back off the part while the gap lies along the other edge, was refused
at every corner. A part's only open cut now measures toward its gap.
Cutouts cut in pieces keep the old rule.
- Travel measured from before the part, not from its cutouts.
A holed part now tries first the outside entry where the straight line
from its cutouts to the next part's leaves it: the shortest way between
them. The search and contour recovery both lead with it; every check
still applies.
The problem-nest corpus ranks no plate below its baseline, and none at
80% of its budget; five ConstraintConflict plates now plan BestEffort.
Five planning fingerprints change, all still Ready: rapid travel drops
14-17% on four and rises 0.5% on mixed-irregular. A kept-order replan
after a cut-off segment may now find a shorter route than the plan, so
that test checks the route is no longer rather than identical.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Options is now a sidebar of pages (General, Nesting & Cutting, Fill
Strategies, Nest Server, MaterialLedger, Updates), each with a heading,
a summary and hints under its fields; the window is resizable and
reopens on the last page used.
Nest Server lists the saved servers in an editable grid (add in the blank
last row, remove any but the active one) with an Active server dropdown.
The list saves with the dialog's Save after every row is checked, so a
bad address saves nothing and keeps the dialog open.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Whole jobs placed by the fill strategies could put parts on a clamp
keep-out in three ways:
- A best-fit pair left flush on a keep-out was compacted with the clamp
obstacles held at the part spacing, so it already read as inside that
spacing; the push ignores contacts that already overlap and carried
the pair through the clamp to the sheet edge. CompactPair now holds
clamps at zero spacing, as the settle does.
- The pack area was narrowed to a clamp-free remnant only after a fill
had placed parts. With nothing filled the leftovers were packed across
the whole sheet, clamps included. They now get the same remnant.
- A rail with zero clearance left placement no margin over the
validator's keep-out, whose outlines are rounded to a 0.0001 grid, so
a flush edge could read as inside the zone. Placement keep-outs now
grow by at least the spacing slack (0.0005). The expand-spacing walls
keep the exact clamp clearance (WallRectangles).
No tolerance or validator changed.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
Lattice and the two Remnant strategies packed only items that were never
filled, into one remnant, and dropped whatever a fill left of its own
item. The fills see each earlier fill as one envelope, so a part's box
can still fit between the parts of the finished layout, and the one
remnant the pack tried is often a sliver that holds nothing.
After the pack-first or pairs-first step and before the settle, every
item with demand left is now offered to the remnants of the whole work
area through LeftoverPacker, clamp keep-outs counted as occupied. The
earlier steps are untouched, so a nest with nothing unplaced comes out
as before.
Three pinned nests gained parts and none lost one: mixed Fill 34 to 35,
mixed Horizontal Remnant 30 to 35, learned-angle Horizontal Remnant 24
to 26.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
Linear fill finds how far a pattern's next copy must sit by sliding each
part of the copy against the parts of the pattern, and it skipped every
pair whose bounding boxes do not overlap across the slide. A part whose
box lies beside the copy's path by less than the part spacing was never
measured, so the copy could pass it closer than the spacing: columns of
a gusset pair tiled 0.04 apart (the pattern Irregular's band search had
to reject), and an Extents column pair of D-shapes 0.01 apart.
The copy distance now skips a pair only when the boxes are beside each
other by the spacing or more. A part beside the path moves the copy only
when it needs more than Epsilon beyond what the parts in the path need,
so a corner-to-corner contact at the same distance leaves layouts as
they were.
The Strip strategy's mixed pinned nest then filled a valid, denser row
of D-shapes and lost its single rectangle: the pack step tried only the
first remnant, now a sliver along the top edge. Strip offers its
leftovers to the remnants in order instead (LeftoverPacker), packs the
first that takes a part, finds the remnants again and stops when none
takes one. The nest holds 35 parts again, and the whole-plate
characterization nests are now validated as they are solved.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
A file such as a sheet of ornaments imported as one drawing, with every
part but the largest treated as a cutout. PartBodies (Core) now finds the
separate parts by contour nesting, and the CAD Converter offers a
Separate (N) button plus Separate This Part / Separate All Parts in the
entity menu. Each part keeps its entity IDs, so roles, exclusions,
breakoffs, tabbed cutouts and dimensions follow it; separation is refused
when a breakoff or tabbed cutout spans parts.
SVG import keeps element titles as labeled regions, which name the
separated parts.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
An Auto Nest problem nest recorded only a sheet count and where its last
sheet ends, so seeing the layout behind those numbers, or telling
whether a change still made it, meant nesting the old code again.
With OPENNEST_PROBLEM_NESTS_RECORD=1 the auto-nest area now saves each
nest whose layout is valid, complete and no worse than its baseline back
to the corpus server as a new revision: its plates become the layout
Auto Nest just made, on the sheets the job nested on, and its line ends
in "layout saved". A nest without a baseline gets its first one that
way. What was on the plates before stays in the earlier revisions.
- A layout inside the tolerance past the recorded end keeps that end,
so repeated recording cannot let the baseline creep.
- A nest that also guards planning or fill is not saved (those tests
read its plates), nor a layout leaving one of the nest's sheet sizes
unused (the job takes its sizes from the plates).
- A nest whose saved layout and line already match adds no revision.
Without the variable nothing is written; a run reports for each saved
layout whether Auto Nest still makes exactly it.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
On a saved nest of the README sample parts (130 copies, 60 x 120, 0.3
spacing, bottom clamp rail) Auto Nest ended at 105.8 where a hand layout
of tidy bands ends at 103.1. Three things kept the banded fill from it:
- Lattice's first pattern for the 24 gussets set two columns 0.04 apart.
The band's certification rejected it and the band search stopped, so
the gussets had no band and filled the gaps as ragged columns. The
search now asks again just short of the rejected pattern
(BlockCatalog.RejectedBandLength).
- Building patterns is charged to the same work meter as the trials of
narrower and lower bands, and with the lower bands it spent the whole
budget, so the last types in the order never had a trial. Trials now
go round the types and may spend 25,000 work whatever the budget.
- A band taller than the height clear of the clamps lost members to
them. The first lower band is now asked for at that height and
searched like the full band; where such a band would stand whole in
place of one that loses members, the bands are searched a second time
with it there and the better sheet kept. A lower band no longer than
the full one stands first in its place, leaving a strip beside it.
That nest now ends at 103.1, the same parts built from the README DXFs
at 104.0 instead of 106.6, the help tutorial nest at 33.6 instead of
34.2; N26-2HH stays at 103.9 and the other benchmark jobs are unchanged.
Solves of these jobs take about a tenth longer.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
auto-update.md and the development build's release text named the old
Include development builds box. They now name Tools > Options > Updates,
list the four choices with when each checks, and say how the once-a-day
and once-a-week clock starts and that Check for Updates never waits.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Tabbed parts (outline open at each tab) were drawn as bare outlines, so
the new drawing colors could not identify them. They are now filled in
their color, the fill bridging each tab gap while the stroked outline
keeps its gaps. A hatch would vanish on thin tabbed parts, so the mark
is a "*" on the diagram label and the parts-table ID, with a legend line
under the diagram sharing the removed-clamp note's line.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
N26-2CN's 13 x 1 in bars are 9.6 pt tall at overview scale, just under
the 10 pt ID, so none passed the in-part test. Two drawings share rows,
so each drawing's group rectangle took in the other's bars and was
refused, and leaders reached only the edge bars: most of the sheet had no
ID. A strip that thin now takes its ID at its pole, overhanging its own
outline by at most the clearance and touching nothing else.
As a last resort for parts no ID can reach, each drawing is filled in a
light palette color on the plate diagram and its card thumbnail, and its
ID cell in the parts table carries the same color as the key.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A 10-drawing plate (N26-2CJ, sent out for quote) spilled its last three
parts-table rows onto a second page. The generic legend lines (hatched
clamps, ruler units) explained what the page already shows, so they are
gone; only the removed-clamp line stays, since it is an action before
cutting. The diagram drops from 320 to 265 pt so ten rows still fit with
an estimated cut time and that clamp note, the worst case.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
An auto-nest baseline was a sheet count. A job that does not fill its
last sheet can get much worse without taking another one: N26-2CJ went
from ending at 75.2" to 62.1" on one sheet either way, so the corpus
would have passed a layout back at 75.2".
The baseline line may now also say where the last sheet ends,
"auto-nest: 1 sheets, ends 62.2": how far along the sheet's length its
material reaches, measured from the end the layout starts at, the same
figure in every quadrant. At the baseline's sheet count a layout ending
more than 0.05 past it fails; one ending sooner is reported with the
line to record. A line without "ends" checks the sheet count alone, and
older code reads the new line as its sheet count.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
On a sheet with a custom outline the plate edge review, Auto Nest's layout
check and the runner's candidate validation tested the part's spacing
outline against the usable area. That outline circumscribes arcs by up to
0.001, more than any of their slacks, so a disc whose true bounds rest on
the work-area edge read as inside the outline's edge spacing (or off the
plate at zero spacing) while the same disc on a rectangular sheet, judged
on its true bounds, was clean.
The outline test now works as the part-spacing check does: the spacing
outline finds the candidates and a failure is confirmed on the part's
native contour (NativeContours.Region: arcs circumscribed at 0.000025 and
clipped to the perimeter's true bounds). Both regions contain the material,
so a part past the usable edge by more than the slack still fails; no slack
changed. The runner now calls the layout check's own outline test
(NestLayoutCheck.InsideOutline): its separately flattened candidate could
accept a pose on a slanted edge that the layout check then rejected.
Pushes on an outlined sheet measured the same circumscribed perimeter so a
part would rest where the review passed, and box pushes stopped 0.0012
short of a wall for it. With the review confirming on native contours they
slide the material's own lines and arcs, so a round part rests on a wall
exactly as on the plate edge, and a box push rests the box on the wall.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
A part whose planned outside carries a perimeter tab could not be pushed
away from a neighbor it rested against at the part spacing, and the
neighbor could not be pushed away from it: the push returned 0 with open
sheet ahead. It showed whenever the neighbor's bounds wrapped the part
(an eared or C-shaped neighbor), since otherwise the broad phase skips an
obstacle that is wholly behind.
The tab stops the cut short of its entry, so with the leads dropped the
outside is an open chain. Its spacing-offset contour does not close, the
slide kernel cannot tell which side of it is material, and it blocks
every contact against a boundary it cannot resolve. The parts were never
closer than the spacing.
PartGeometry now closes a tabbed contour across its tab before any
offset: the trimmed last cut is restored along its own line or arc
(exact), a round outside cut as one arc becomes its circle, and a tab
that swallowed whole entities is bridged by its chord, as flattening to
a polygon already closes it. Only a single gap is closed; closed
material is returned untouched, so untabbed parts and the fills see the
same geometry as before. No kernel code or tolerance changed, so a push
into a neighbor still returns 0 and a contour cut in several pieces
still blocks.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
The frontier rule lets the sheet state pick the next part and sends
small parts first, so a part as long as the layout can end up behind
them and set the sheet's length. On N26-2CJ (two 55" plates, rings,
sectors, an arc and strips on 48 x 96) Auto Nest ended at 75.2" where
the hand layout, both plates stacked along one edge, ends at 63.5".
After the search, pack the last sheet's parts again in a given order,
largest first, each at the lowest point across a strip that ends short
of where they reach now, and search the order (single-part moves, then
seeded swaps) for one that fits them all. Each strip that takes them
is followed by a shorter one. Parts that may turn freely are also
offered every 30 degrees. Work is counted, the seed is fixed, and the
squeezed sheet replaces the plan's only when the plan then ranks
better. N26-2CJ now ends at 62.1", leaving 33.4 x 47.5 against
20.3 x 47.5.
A search over few parts runs out of new orders, and decodes it has
already made cost no work, so it also ends after a run of rounds that
place nothing new, and its per-strip budget shrinks with the part
count.
CurvedPartsClearEveryInflatedClampInEveryQuadrant asked for a disc on
the sheet edge between the clamps. The squeezed sheet is 0.1" shorter
with that disc wedged on a clamp's corner, so the test now asks for a
disc below the clamps' tops.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
A concave no-fit polygon is the union of the convex sums of every pair
of pieces of the two footprints. One Clipper union of all of them meets
each overlap of each pair of sums, on the order of (p*q)^2 pairs: two
line-only arc outlines of 150 vertices took minutes, and an eleven-part
job of rings, sectors and an arc spent 110 s of its Irregular solve
there.
Union the sums of each piece of the moving footprint first, then merge
those results in neighboring pairs. The same job solves in 3.3 s with
the same layout, and the benchmark jobs keep their placements.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
A plate with a custom outline was pushed against its bounding box only, so
a part pushed toward a missing corner ran through it to the box edge and
ended off the sheet. Compactor's plate pushes (Push, PushBoundingBox,
SettlePlacement, Settle) now also stop at the walls of the outline: the
part of the work area that is not usable material (a missing corner, an
obstacle, each grown by the largest edge spacing). A mover is measured as
the edge review measures it, by the circumscribed perimeter of its clean
material without leads, so it rests where that review still passes. A box
push stops 0.0012 short of a wall so the geometry push after it starts
clear. A rectangular sheet has no walls and pushes exactly as before.
SheetOutline.FromGeometry eroded the whole imported outline by the chord
tolerance, so a sheet drawn 60 x 27 was stored as 59.998 x 26.998 with a
chamfer at every inside corner. Each arc is now chorded on the side that
takes material away (ClipperBridge.FlattenOneSided) and straight edges are
kept exactly. The plate header, the plate list and Edit Plate's outline
size show the size rounded to four decimals instead of the raw double.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
Bands were always the full work-area height and placed flush to the
bottom or top edge. On N26-2HH (20 + 20 formed legs, 60 x 120, bottom
clamp rail) the larger leg's full-height band had less slack than the
rail's depth, so three copies dropped to the gap fill and Auto Nest
ended at 104.71 against a hand layout at 104.0.
Each type now also offers up to three lower bands, each asked for just
short of the last band's height and searched over three lengths, which
leave a strip along the sheet for the remaining parts. A band that would
lose members to clamps also tries the top edge and just past the clamps
lining either edge (ClampObstacles.ClearOfEdges, moved out of
EdgeFirstFill). N26-2HH now ends at 103.87; the README sample, help
tutorial and N26-2GT layouts are unchanged.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Each released nest's progress window offers the top-layout cards and
Use This Layout, as Auto Nest does: using one stops that nest's search
and goes on with it. A search that finishes with several layouts counts
down 5 seconds before going on with the engine's result; picking a card
stops the countdown and waits for Use This Layout or Discard.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Make Nests with Nest after release ticked now nests what the MaterialLedger
stock cannot hold on the plate sizes the nest's machine lists for its
material, grade and thickness (Machine Configuration's Plate Sizes tab),
instead of the Nest Defaults sheet or a draft's saved options. The sizes
become the nest's plate-size options, converted to its units (standard
sizes are inches, custom ones the machine's units); a thickness listing
none keeps the previous behavior.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Releasing element-rack jobs from an agent meant hand-writing a console
runner around SetReleaseSession, posting set JSON by hand (opaque
"Invalid set JSON." and 428 without If-Match) and re-nesting by hand when
the 60x120 default wasted sheets. The MCP server now does it through the
desktop's own clients and release session:
- search_drawings, get_drawing, search_sets, get_set
- create_set, update_set, archive_set, restore_set (revision guard handled)
- plan_release: material groups, refusals and mergeable drafts, read-only
- make_nests: SetReleaseSession with headless ReleaseRenest, File > New
nests from NewNestSource (server-allocated names), MaterialLedger when
set up, optional merges into drafts
- renest_nest: re-nest a Draft/Quote nest, saved with the expected-revision
guard only when every part is placed
- nest_summary, get_release, undo_release
make_nests and renest_nest take candidate sheet sizes: each alone and all
together as plate options are tried on copies, keeping the fewest
unplaced, then fewest sheets, then least sheet area, because the engine's
own stock choice minimizes area, not sheet count.
Tests run the tools against the in-process server; docs in
docs/mcp-nest-server-tools.md.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A thin strip on N26-2CJ had no ID in the plate diagram, and a half ring's
ID landed in the open side of its C shape, away from the material. The
in-part fallback searched the whole bounding box, so concave openings
counted as the part's own space.
That fallback now uses only enclosed holes. A part still unlabeled after
grouping gets its ID in the nearest clear space outside it, with a thin
leader to a dot at its pole; the leader crosses no other part, cutoff,
clamp, label or leader. Tiny parts whose ID other unlabeled parts share
get no leaders, so an ungroupable cluster does not bury the sheet in them.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A nightly corpus runner keys every area's results by the subject before the
colon, so the fill line now reads "<nest> plate 1: 33 parts (baseline 33),
61.2 s" (strategy other than Lattice in the subject) instead of putting the
plate number in the outcome.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Fills had no corpus coverage, so a fill-engine change could lose parts on
a real nest without any check noticing. Nests whose checks: line names
fill are now filled plate by plate the way Fill Plate does (parts cleared,
cut-offs kept, the plate's own size, spacing, edges, quadrant and clamps)
and held to a "fill: 1=33" part-count baseline, with an optional strategy
("fill (Strip): 1=33", Lattice by default). Fewer parts, a layout that
fails the layout check, or a timeout fails; more parts are only reported.
A missing or mismatched baseline prints the observed line to paste.
AGENTS.md now sends fill-engine changes to the fill area only, instead of
never running the corpus for fills.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Automatic cut-offs matched existing cut-offs only on the exact same line,
so a grid line could land a hair beside a manual cut-off (or the planner's
own tail separator) and cut a sliver strip next to it. The planner now
keeps a cut clearance - the separator's part margin, the larger of part
spacing and cut-off part clearance - from every parallel cut-off:
- a full-span cut-off within it stands in for the proposed line (or the
tail separator) and is certified at its own X;
- a shortened or gapped manual cut within it is a blocking conflict, as an
exact same-line conflict already was, and the shift search avoids it;
- a strip line within it of a kept separator or full-span boundary is not
cut, letting that strip run past the spacing by less than the clearance;
the open sheet end keeps the bare tolerance, since oversize stock leaves
its far edge unknown;
- a new horizontal separator beside an unhonored horizontal cut-off is not
proposed.
With zero clearance and part spacing the guard falls back to the old
same-line tolerance.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The CAD Converter's Export button only wrote DXF (or SVG) with every entity on
layer 0 and no bends, so a re-imported export lost its bends and turned the
bend etch marks into cut geometry. Exporting now goes through a new
OpenNest.IO CadExporter:
- DXF R14-2018, DWG 2004-2018 or SVG. ACadSharp cannot write DWG 2007, and
its DWG 2000/R14 output loses entities and layers, so those are not offered.
- Entities keep their layers; etch marks land on ETCH, which import drops and
regenerates from the bends. A line picked as a bend is written only as it.
- DXF/DWG bends are BEND-layer CENTER lines with an "UP 90° R 0.06" MText note,
the form SolidWorksBendDetector reads. Pre-2007 files escape non-ASCII note
text as \U+XXXX, since ACadSharp reads raw non-ASCII back mangled.
- SVG bends are lines in a BEND group with data-bend-* attributes; the SVG
reader now returns them as bends (scaled with the drawing units) instead of
dropping the layer.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The nest window rechecks the active plate automatically half a second after
each edit, so a manual run/cancel pair in View > Overlap Check is redundant.
With only Display left, its Off/Areas/Markers/Both items move up to sit
directly under Overlap Check. Auto Nest still runs its explicit check, and
undo/redo still cancel a running check internally.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Stock-trial pruning in tail re-plans now starts only once the block budget
is spent. Before that, a skipped trial left a Lattice block attempt and its
work unspent, so a later trial could prepare a block it was refused before
and the decode could choose differently.
The quick plan no longer demotes the normal search's plans to
alternatives. The deadline wrapper, the only caller that enables
SearchUntilCancelled, already keeps the best reported plan that passes the
layout check, so a quick plan that failed the check could have hidden
valid plans. The docs drop the measured timings.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A tail re-plan's decode no longer packs a stock whose least possible net
cost (the whole sheet, less full salvage credit) already exceeds the best
estimate so far and whose cost ratio over the remaining part area cannot
beat the best so far. Later trials only lower the ratio and the estimates,
so the skipped trial could neither be chosen nor change the choice.
On N26-2GT this skips ~60% of the tail re-plans' trials, a fifth of the
ungrouped search's packing time. Layouts and reported plans are unchanged
on every unlimited benchmark job and on the N26-2GT and readme-mixed
oracles; first-nest's unlimited Irregular solve ran in 75 s rather than
100 s. Whole-job variants still pack every trial, since a skipped stock
may have finished the job.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A solve that can end only at its limit (SearchUntilCancelled, a cancellable
token and a listener) now decodes the first variant once without Lattice
blocks before its normal search and reports it. Block preparation for each
stock trial of the first sheet takes most of the first decode on big jobs:
on N26-2GT Default showed Irregular's first plan after ~29 s, now ~5 s.
The quick decode runs on its own work meter and shares only job-determined
caches, so the normal search decides as before; until one of its plans beats
the quick plan, they are reported as alternatives. Unlimited solves never
make a quick plan, so their results and reports are unchanged.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A free rectangle narrower than the part at every rotation (its convex-hull
width, less the outline's flattening tolerance), or smaller than three
copies, can only give Fill two members or fewer, which never form a block.
Block and band requests for such rectangles no longer run the Fill. They
still count as a preparation and are charged as before, so the work meter
and every layout stay byte-identical. On N26-2GT this skips 31 fills
(about 7.6 s of fill time across the solve, 0.4 s before the first plan).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
FillLinear.FillDeferred returns a grid whose final overlap check has not
run; Resolve runs it and returns exactly what Fill returns, and Fill is
FillDeferred(...).Resolve(). PairFiller sorts a candidate's grids with
CompareByCount, which answers from the counts a pending grid can still
have (its tiling or its bounding-box fallback) and runs the check only
when they could order the pair differently; the early abort and the
remnant pass resolve the grids they use. Every answer equals the checked
comparison, so List.Sort makes the same moves, ties included, and
layouts are bit-identical. A check that throws during the sort surfaces
unwrapped. On the bracket fill this skips about 35% of the pair grids'
final checks by work.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Collision.HasOverlap, Check and PartOverlapChecker now triangulate into
CollisionTriangle values (each ear's open vertices and box sides) and clip
them in two reused stack buffers, instead of building a Polygon entity per
triangle and three lists per clip. Same ears, vertices, bounds, pairs and
arithmetic, so verdicts and regions are bit-identical.
On the N26-2GT job a 30-copy Lattice fill of an 80-vertex arc-cornered
bracket fell from 15 s to about 4 s with identical poses, and Irregular's
first plan from 66 s to about 26 s, inside Default's 60 s limit.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Adding from the Drawing Library now shows a slim green banner naming what
was added (or how many more, with the new required quantity). Each add or
In This Nest quantity edit raises NestChanged, so the main window lists the
drawing on its Drawings tab behind the dialog right away, brings that tab
forward and selects it, instead of waiting for the dialog to close.
The library form tests restore the WinForms synchronization context before
each add: DoEvents leaves a plain one behind, which sent the add's awaits to
the thread pool and created the banner's window there.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The first v0.7.0 publish stopped at preflight because GitHub answers a
missing user package with 404 "Package not found." (documentation_url
.../rest/packages/packages#get-a-package-for-a-user), while the check
only accepted "Not Found", a shape the tests had assumed. Accept that
message too, require the packages documentation URL, and pin the real
body in the tests. Other 404 shapes still stop the job, and the registry
must still report the repository unknown.
The publish job checks out the tag and ran that tree's release helper for
preflight and readback, so an older tag (v0.7.0 requires a private
package) could never publish under the current public policy. Copy
master's helper before checking out the tag and run preflight/readback
from it; the tag's tree is still what gets built, tested and smoked. The
helper is stdlib-only and its local identity stamp is unchanged since
v0.7.0, so the two copies agree on it.
The repository is public and the image carries its source label, so the
first GITHUB_TOKEN push creates a public package linked to the repo and
no manual bootstrap is needed. Preflight accepts GitHub's own package
Not Found only when the registry also reports the repository unknown (a
package hidden from the token still has one); every other error still
stops the job. Readback refuses a package still missing after upload,
and the anonymous pull proves it is public.
The repository is public, so a private image only made every deployment
host log in to ghcr.io. Publication now requires the existing package to
be public and linked to ajisaacs/OpenNest (private or wrong association
stops before upload and is rechecked after it), and the clean-runner
verification pulls the returned digest without logging in, proving
anonymous pulls work. Docs describe the one-time package setup and drop
the deployment-host login; the server itself stays LAN-only.
Common-line cutting and the CI Fiber output docs called the machine check a release gate and named the shop's machine and coupon; they now say the single cut is not yet proven on a machine and how to check it. An engine example no longer names an internal job, support-tab settings name the Cutting Parameters dialog, the Avalonia colour doc mentions its Options scheme row, and the post doc says replan.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A multi-part pattern tiles from the work area's leading edge, so the copy
before the first one never fits whole. When the tiling leaves room at its
far end, FillLinear now moves it forward by the smallest shift that fits
the most parts of that previous copy and adds them. On an arch/cup
herringbone this fits the cup row under the first arch row: 121 -> 132.
Comparisons against the frozen fillers turn the new step off through an
internal LeadingParts flag and check the default fill separately.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Ctrl+F while pasting one common-line group fills the area with the group's
single merged outline as one part, then turns each placed copy back into its
parts joined at the source kerf. The old pattern fill tiled the members as
loose parts, added lone parts and joined nothing.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
A tabbed part stays in the sheet, so rapids were free to pass over it and
the planner never looked for a way around. Plan Cutting now searches first
with every tabbed outside as an obstacle once its part is cut. Where a pass
stalls at a part whose approach crosses a tabbed part, only the crossed
parts become crossable and the search goes on along the same order. A
capture that search cannot plan is planned as before. Plates without
tabbed outsides are searched once, unchanged.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
5776fa80 dropped a tabbed outside's lead-out when it would reach the lead-in,
which silently changed the user's cutting settings. The emitter now keeps the
lead-out as configured again. Plan Cutting plans strictly first, as before;
only when that is refused because such a lead-out may cut its tab free does it
plan again keeping the lead-outs. Each affected part gets a "Tab lead-out"
issue (new PostVerificationKind.TabLeadOut), is treated as cut free for later
rapids, and the plan is UNVERIFIED, so applying it needs explicit acceptance.
The short reorder pass never settles for such a plan, so a clean route still
wins. Locked, fixed and posted programs keep the incomplete-check finding.
The "no single tab can steady it" support warnings caused more trouble than
they solved, so a tabbed part now counts as steady wherever its tab is: Plan
Cutting and the pre-post review warn only about a part cut with no tab at
all, and a tabbed part stays crossable once cut instead of being avoided as
one that may tip. Entry choice still prefers the steadiest tab point.
The problem-nest corpus is unchanged except N26-2AM, whose baseline is now
BestEffort with 15 tab lead-out warnings.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A tab stops the outside cut short of its entry, and the lead-out leaves from
there. On a counterclockwise outside a line lead-out angles forward, toward
the tab: a 0.1 lead-out at 60 degrees runs 0.05 along the edge, past a 0.03
tab, and crosses the lead-in, so the two cuts sever the tab. The released-
contour check rightly refused every such part, so a plate of support-tabbed
strips found no cut plan at all.
The emitter now drops a tabbed outside's lead-out that touches the lead-in or
passes within a kerf of it, as tabbed cutouts and breakoffs already end at
their tabs. Lead-outs that stay clear and untabbed contours are unchanged.
The tests that expected the crossing leads now expect them left out, and a
new test keeps the check's refusal of a crossing lead-out covered.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Irregular picks each sheet's stock on an estimate of what the leftovers
will cost, so a size that took every remaining part could lose the pick
to a plan that ended up dearer, and its trial sheet was thrown away.
Each pass now keeps those finished plans: one that beats the pass's own
plan replaces it, and the rest are reported as alternatives (at most six
a pass). No extra sheets are packed.
The progress window's layout families now include the sheet sizes, so a
one-sheet 60 x 120 layout is offered beside a one-sheet 48 x 144 best
instead of being dropped as a near copy.
With 48 x 96, 48 x 144 and 60 x 120 offered, the seven sample parts (130
copies) still take one 48 x 144 sheet and now end at 130.7" instead of
136.6"; the tutorial and synthetic nests are unchanged.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>