The window's column takes one held-height state shared with the collapsed
column: WindowColumn::held is the content height, and collapsed the strip's
own width. A column whose every group is minimized shows at its rect's place
and width with the title row and strips' height (DockSizes::minimized_height);
its sides resize the width, and WindowColumn::kept keeps the rect's height, so
an OS window's recorded placement and an in-app window's rect keep the
expanded size and a restore gives it back. Stepped columns keep fitting their
content, which already measures minimized groups as strips.
Fixesstorytold/photocraft#15862.
A collapsed dock window's sides resize its width, and only its width, within the bounds of a docked collapsed column
(DockSizes::iconic_bounds, the one rule both use), on macOS by AppKit and elsewhere by the window's own grips.
FloatingGroupOutput::collapsed_width reports the width, which the area keeps as the column's iconic width through the
docked column's own path (Action::ResizeIconic); names show from IconicSizes::labels as in a docked column. The height
stays the icons', the expanded rect keeps its size and the window keeps its edge. The column in a window has no
inner-edge divider: the window's sides size it, as for an expanded column.
- A panel's grid is read only through DockSizes::stepped, in the dock's own sizes, so
DockGrid::rail is converted in one place; ToolRail counts its columns in its scope's
style (DockSizes::of_scope), and ToolRail::dock_grid is gone.
- A layout's window counter starts above every id it is built or loaded with; a dock
area raises a workspace an undo brings back above every id it has shown
(Workspace::raise_window_floor). A saved u64::MAX id loads without overflow.
- Floating::id and DockArea::new docs say how ids are given and why to keep one Arc.
Part of #2336.
- `Workspace` fields are private. `revision()` moves with every write (a clone is a
new source); `generation()` moves only on `replace` and ends drags as the old
revision did. A trial walks every `&mut self` method, read from the source.
- Panel specs and permissions leave `DockPanels` for `PanelSpecs`, a plain-data model
the host keeps in a `Tracked`. `DockArea` binds `Arc<Workspace>` and derives specs,
permissions and keys from the workspace revision, the specs revision and the lock:
an idle pass reads no spec, read-only docks included.
- `DockGrid::rail(cells)` is sized by the dock from its own tokens.
- Floating window ids come from a counter the layout owns; `replace` gives incoming
windows ids the replaced layout never gave out. The dock's global id counter and its
`no-global-state` allowlist entry are gone.
Part of #2336.
A dimension that belongs to one component's own drawing is a documented
constant in that component's file; layout sizes stay semantic tokens, and
no size-preset token exists for one component (craft-framework.md 5.4).
- Spec: 5.4 rule 3 reworded; Appendix A, 4.6 (the component-token rung
goes, no such tokens exist), 8.3, porting.md and the theme README agree.
- design-lint: literal-size/* treats a module- or impl-level const with a
doc comment as a named value: a name that resolves to it is not flagged,
and its initializer is its definition. Fn-local and undocumented consts
and call-site literals stay flagged. Nine markers that only covered such
consts are removed.
- Ruler ticks: size.ruler.tick.* leaves the size presets; kit.rs draws
TICK_MID = 6 and TICK_MINOR = 3 points in every density, as the old
library and the apps' rulers do. Comfortable ticks go back to 6 / 3
(from 9 / 4.5); Compact is unchanged.
- size.scroll_fade becomes FADE_LENGTH in scroll_bar.rs, size.notice.width
CARD_WIDTH in notice.rs, and size.story.* multiples of size.control.md
in testing/stage.rs (15, 10 and 30 control heights: today's values in
both densities). pointer_tip, checker, thumb.sample.*, the card gaps and
icon.glyph_md stay tokens: each has more than one user.
Sensing grows every part's hit area to the pointer's target size (size.hit.target, 8 pt), so a 6 pt grip reached
1 pt past its rect on each side: a press 1 pt into a floating window's title row started a top resize, and the top
corners of a banded layer (6 pt tall) reached 8 pt. A part declared exact_hit keeps its declared shape as its hit
area. Every window grip and the edge pane's grip declare it: a frame's grip band is sized as its reach, its
neighbours own the points beside it, and the in-app hit area matches the platform's hit test for an exclusive grip.
docs/contract-api.md regenerated.
- The floating window's title row is one text row high (HeaderStrength::Bar, size.row.text: 18 pt compact), as
production's 18 pt bar; the tab strip below keeps the panel header height.
- A resizable or movable layer with a header keeps its top grip's band (contract::grip_band, size.handle.sm) clear
above the header, so the top grip never lies over it; the regions start below the band or the padding, whichever
is deeper. Dialogs keep their layout (their padding is deeper than the band).
- Grips lie inside the frame for layers too; corners reach twice the edge width along each edge (12 pt), top corners
of a banded layer only the band's height.
- Where the OS resizes a window from its own frame (macOS Inset, resizable: windows::os_resizes) no app grips stand,
the cursor over AppKit's resize areas is the default (craft_window::mac::in_resize_area) and the move band keeps
the arrow, as an OS title bar does.
- DockSizes::window_chrome (title row plus the band in the app window) sizes floating windows, stepped resizes,
collapsed windows and float previews (FloatSpace::chrome).
next's WordCraft port and the framework work under it (243d68e12d) take the memoized-view APIs where they meet the
branch: story values bind through StoryData::bind, value_at and pair_at (next's copy-out stories included; one held
form story still binds a copy, as its held answer is a note beside the value); next's env values (GroupLevel,
ControlPlace, RibbonLook, ScreenModeSet), IconMark and PageBandRoom derive MemoProps, and the shell entry keys the page
band's room; request_own_repaint calls become request_repaint. The collection extent next reworked (motion-owned
style context, FillHeight, ideal width by item count) moves into items_extent. The header's hosted cells join the
parts' roving group from the pass's own membership (parts_group over Cx::join_roving), as the parts' stops do. A
content-sized shell slot measures its content with the app running in it every pass. The gallery card hands the
story's output from its view's real run (StoryRun).
Memoized views stay the one change mechanism: next's settling-path additions (modifier reads as bind keys, given-edit
and keymap unsettling, settle counters) give way to the tracked inputs that cover them, and request_own_repaint calls
become request_repaint. next's command board, node facts after the node check, the guide drag out of a ruler and the
CommandStates input are taken; the trials next wrote on Lazy::settles run on memoized views. The ruler guide env value
keys a view under the canvas in every pass of a drag. The replay audit's run in the gate takes next's target selection.
A face measured by MeasureCx::face is part of its composite's measure
call: that call's answer and the inputs the faces read are the record
the layout memory keeps and checks. The face recorded a leaf of its own
under one id shared by every face of the composite, so only the first
face was kept, and a change to it that left the composite's size alone
dropped the kept measurements and asked for a discard pass.
measure_face measures a face as measure_under does, without the leaf.
TextRun::least (MeasureCx::least) returns the run laid out whole with its
least width, so a text measured at Proposal::Min no longer lays the whole
line out a second time for its height. A fitted select face takes its cap
from the same call. A select of 29 blend modes plus the mixed word lays out
56 texts per Min ask instead of 86.
Lazy::settles, Lazy::content, Key::Version, the input and unsettle rules
(Changes::input_through, unsettled_through, scan) and lazy::unsettle with its
callers are removed. frame::request_repaint marks the record of the view it
is asked in and reruns only that view; asked outside every view, every view
replays. request_own_repaint goes; ui-canvas calls request_repaint. Pages
measures each hidden page once per pass. The tests that used the old API are
memoized views, with trials for repaints in and outside views and for
given-value edits. API map rows and the framework doc describe memoized
views.
Merges main at d7c9632bfb.
- Cargo.toml: both sides' new workspace crates (next's font-subset, harfbuzz-subset-sys and
host; main's gpu, gpu-null, gpu-providers and gpu-wgpu).
- crates/jpeg: next split lib.rs into modules; main's reduced-size decoding goes to them: the
scaled IDCT, reconstruction and render_scaled to idct.rs, MAX_SHRINK, reduced_estimate and
decode_reduced stay public in lib.rs. Main's new test added; the frame test next removed
stays removed.
- crates/audio, crates/media: next builds the integration tests into the library's test
executable (autotests off, tests/main.rs); main's new DSD and MPEG-TS mux tests are modules
there behind their features instead of [[test]] targets, and the mux tests reach their shared
helper module through the integration module.
- crates/media/src/matroska/track.rs: main's new FFV1 codec-parameter test added; the test
modules next removed stay removed.
- crates/file-formats: main's JXL capability test, which asks the codec whether JXL reads,
replaces next's interim check.
craft_automation::agents kept its own copy of the agent settings, the
launcher's switch and the connection file beside craft_control::agents.
It now re-exports craft-control's (and with it the CLI's live client)
and keeps only the egui link host. The Agents page is unchanged.
Callers see two API changes: AgentSwitch::watch takes a closure
instead of craft_host::Wake, and the connection functions return
std::io::Error. AgentSettings is #[non_exhaustive] in another crate
now, so the trials set fields on a default instead of using struct
update syntax.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Each kept resolution holds the key of what it read: the state's revision,
the gate's key and answer, a shared generation (keymap and catalog, scope
parents, instances and their liveness, modal facts) and, when read, the
focus generation, the focused stop's edits and a layer's or menu's vantage.
A reader whose key holds gets the kept Arc<ResolvedCommand>; the wake at
the start of a pass walks only when an input moved. CommandGate is a fn
plus props, asked once per command per key. App-scope states come from a
held Tracked<CommandStates>. resolve and resolve_command return
Arc<ResolvedCommand>. Under testing, every 100th pass compares every kept
resolution with a full one; count_resolve counts new, repeated and checked
resolutions.
* craft-gpu: add the GPU job traits and the shared providers.
This carries over crates/gpu, crates/gpu-wgpu, crates/gpu-null, and crates/gpu-providers from the cut-down #160 branch, with minimal workspace wiring.
None of these crates names a vendor or any app. craft-gpu defines GpuJob and ProviderRegistry. craft-gpu-null is an in-memory context for tests. craft-gpu-providers holds the shared craft.* WGSL providers. craft-gpu-wgpu is the wgpu backend, native and WebGPU.
* craft-gpu: real device wiring, device loss and async readback (RFC-0022)
Addresses skylartaylor's review gate on #663 at 138f7b2. RFC-0022 has merged
since that review. This follows its acceptance requirements.
WgpuContext now requests a real device. DeviceCaps comes from that device,
reflecting the limits and features actually enabled on it. Buffers are real
wgpu::Buffer values when a device exists. The no-adapter case still degrades
to the same staging behavior as craft-gpu-null. The RFC defines that case
explicitly as the no-adapter path. Device loss is registered via
set_device_lost_callback. It surfaces as GpuFault::DeviceLost. It never
surfaces as a panic. The recovery is stated on GpuContext's trait docs.
GpuContext::read_buffer is no longer a required method. The primitives are
request_read and poll_reads. That mirrors craft-worker-host's own
HostMessage::GpuJobs to WorkerMessage::GpuBatchDone split one level down.
read_buffer stays as a default blocking convenience. It resolves immediately
on the null and staging paths. Native wgpu blocks on
Device::poll(wait_indefinitely). On wasm32 it returns GpuFault::Operation,
since a blocking wait there would freeze the one thread map_async's own
callback needs to run on.
crates/gpu-wgpu/src/tests.rs adds a real-backend suite, gated on
adapter-probe plus non-wasm32. It runs upload, readback and device-loss
tests against a real WgpuContext. It also runs three craft-gpu-providers
CPU-stand-in providers against that same real WgpuContext. It skips with a clear message when no adapter is present.
Verified against lavapipe with mesa-vulkan-drivers, using
--features adapter-probe,native-vulkan: every test passes. That run first
caught a real wgpu panic on buffer lengths that are not a multiple of 4,
COPY_BUFFER_ALIGNMENT. The fix pads real buffers transparently. Every caller
still sees exact, unpadded bytes.
docs/gpu-backends.md and docs/gpu-providers.md are updated to match,
including named consumers (the runtime slice first, then EffectCraft and
FilmCraft) and a device-ownership note for when egui's wgpu renderer is also
running.
* craft-gpu: buffer-size guards, empty-buffer parity, read_buffer keeps other completions
Answers the six findings in CodeRabbit review 5852678306 on PR #663.
upload_buffer on the device path refuses a padded size past the device's
max_buffer_size with GpuFault::InvalidJob before creating the buffer.
request_read guards its staging copy the same way. An oversized request
used to reach wgpu as a validation error on the device's error scope.
Empty buffers are accepted everywhere, matching craft-gpu-null and the
documented staging parity. The device path resolves an empty readback
immediately (wgpu refuses an empty map range). The blanket InvalidJob on
empty upload bytes is gone.
read_buffer no longer eats completions that belong to another
outstanding request. The wgpu override re-queues them for the next
poll_reads. The null context gains an override that takes only its own
completion. The trait's default-body contract is documented: with the
default body, do not interleave read_buffer with an outstanding
request_read.
ReadbackProvider validates the storage-binding cap directly. The old
chunk_buffer call allocated a Vec of slices only to drop it.
parse_u32 and params_contain refuse an empty prefix or needle.
windows(0) panics and the crate's rule is never to crash.
The manifest guard test now also rejects *-engine dependency lines, per
docs/gpu-providers.md.
* craft-gpu: per-job batch results, wasm staging reads resolve
Two findings CodeRabbit raised against the carried copy on PR 662, fixed here where the crates live. dispatch_batch now answers per job in input order. The old first-failure abort discarded outcomes earlier providers had already produced, leaving the caller nothing to reply with and no way to name the jobs worth retrying. A job fed by a failed predecessor fails honestly on its own bad handles. On wasm32 read_buffer now serves the staging backing, whose reads resolve synchronously. The backing on that target is always staging today. The refusal remains for a read that did not resolve synchronously, guarding the future wasm device backing where blocking would hang the tab.
* Add free_buffer and device_status to GpuContext.
Two CodeRabbit findings against crates/gpu-wgpu, both answered at the
trait level since craft-gpu-null has the exact same gap.
free_buffer (lib.rs:313). Every upload_buffer call added an entry to a
backend's buffer table. So did every output buffer a provider's job
created. Nothing ever removed one. Repeated jobs retained memory for
the whole lifetime of a context. The new required method releases a
buffer's resources. A freed handle behaves as invalid afterward, the
same fault an unknown handle already produces.
device_status (lib.rs:401). poll_reads can only attach a device-lost
fault to a read it has something to attach it to. A caller whose event
loop only polls, with nothing pending when loss happens, could never
observe it. The new method, default Ok(()), covers that gap directly;
a backend with no concept of device loss needs no override.
MemContext in this crate's own tests gets the same free_buffer shape as
craft-gpu-null, to keep it compiling under the new required method.
* Implement free_buffer for NullContext.
buffers moves from Vec<Vec<u8>> to Vec<Option<Vec<u8>>>. A handle is a
stable index. Freeing a slot replaces it with None. Removing it
instead would shift every later handle's index out from under its
caller. buffer_len and request_read now reject a freed index the same
way they already reject one that never existed.
Two new tests. One frees a handle and checks another's index and bytes
stay untouched. One frees a handle twice, and a handle that never
existed, and confirms both are a harmless no-op.
* Fix the no-device caps fallback, capture allocation failures, free buffers.
Four CodeRabbit findings against this crate.
The no-device fallback in WgpuContext::new called probe_caps() again
on request_device failure (lib.rs:228). A second, successful adapter
query would then report the adapter's advertised limits as if they
came from a granted device, for a context that holds none. It now
falls back to the plain, fixed caps probe_caps's own doc comment
already promises for that case.
Allocation failures during buffer creation used to reach wgpu's
default uncaptured-error handler (lib.rs:299). That handler panics.
The size check already in place only catches a request past the
device's advertised maximum. It says nothing about whether the device
can actually allocate that many bytes right now. An error scope around
both the output-buffer and the read-staging-buffer creation converts a
failure into a GpuFault instead.
free_buffer for WgpuContext (lib.rs:313) matches the Option-wrapped
shape just added to craft-gpu-null. Both backings, staging and real
device, release a buffer's resources and make the handle behave as
invalid afterward, without shifting any other handle's index.
device_status for WgpuContext (lib.rs:401) reports device loss through
the trait method just added to GpuContext. A caller that only polls
can now observe loss even with nothing pending.
New tests cover the fixed fallback value and a regression check that
the new allocation error scope does not misfire on an ordinary
allocation. They also cover free_buffer on both the staging and the
real-device path. One more covers device_status observing a destroyed
device with nothing outstanding. A genuine out-of-memory condition is not reliably
reproducible in CI; the allocation-failure test is the honest half of
that fix this can run.
* Fix the error-scope API call and run cargo fmt.
wgpu 30.0.1's Device has no pop_error_scope method. push_error_scope
returns an ErrorScopeGuard. pop() lives on that guard. Keep the guard
from push_error_scope and call pop() on it.
Also drops an unneeded mut on a test binding that never mutates its
context. Also runs cargo fmt on the lines the Option-wrapped buffer
changes touched.
* Drop a needless return clippy flagged in the adapter-probe lane.
The fallback branch in WgpuContext::new is the function's own tail
expression once the real-device branch above it has already returned
early. The explicit return on it was redundant.
* Run cargo fmt on the no-device fallback branch.
* Pop the OOM scope before the call that would misuse a failed buffer.
upload_buffer popped its scope only after write_buffer. request_read
popped its scope only after the copy and its submission. A buffer that
failed to create is invalid. Using an invalid buffer raises a VALIDATION
error that an OutOfMemory-only scope never catches. The default
uncaptured-error handler still panicked on a failed create even with the
scope in place. Pop right after create_buffer in both paths and return
before the buffer is used again, with a separate scope around the later
write or copy.
write_buffer only queues its copy into wgpu's PendingWrites. An upload
with no following submission kept the destination and staging buffers
alive inside wgpu-core until some other submit happened. upload_buffer now
flushes with an empty queue.submit right after its own write_buffer call.
A free_buffer right after an upload can now actually release the
allocation.
* Run cargo fmt on the new ordering test.
* craft-gpu-wgpu: correct the crate docs on wasm32 read_buffer
The staging backing serves wasm32 reads synchronously since the staging-reads fix. Only a read that did not complete synchronously faults. The crate-level summary still described the old unconditional fault.
* craft-gpu: sync the docs with the implemented readback behavior
Review asked for three corrections. The backends doc, the providers doc and the trait docs now state that both bundled backends override read_buffer's default body and that wasm32 serves the staging read, with a fault only for a read that did not resolve synchronously. The runtime follow-up paragraph now records that #662 consumed it. The software Vulkan container run is described as local testing. Hosted CI coverage and the pilot consumers' browser and hardware validation remain their own requirements. Em dashes swept from both docs per the house writing rules.
* has_device: say the answer once, in this file's own shape
Clippy 1.100.0 refuses the old body under `needless_bool`. The `if` returned a
bool literal with a bare `false` after it. The cfg attribute sat on the `if`
itself. The whole statement therefore vanished without the adapter-probe
feature.
Two cfg blocks replace it, one per configuration. `probe_caps` in the same
file already has that shape. `Backing::Device` exists only under that feature.
The clippy suggestion on its own would not compile.
The plain clippy leg never saw this. The line compiles only with adapter-probe
on. The all-features leg catches it, as does any workspace build that unifies
the feature in.
Merges main at 3b8e426a26.
- crates/ui: main's e-sign dialog (crates/ui/src/esign) moves to craft-cloud-ui beside the
share dialog, behind craft-cloud-ui's esign feature; craft-ui forwards `esign` and
re-exports the module.
- crates/proof: main's can_suggest_cased goes to affix/check.rs and its tests to
affix/tests.rs (next split affix.rs); French wiring in lib.rs.
- crates/svg: main's validated resolver and raster validation stay under tree-render, which
now also enables gif and image-webp; the shared image-codec helpers are gated on tree.
- craft-ai-agents: main's rev (craft-ai-integrations main), one entry.
- crates/craft: facade dependencies, features and re-exports for main's new crates.