Skip to content

Releases

Packvium 1.11.0

Choose a tag to compare

@github-actions github-actions released this 16 Nov 18:58
8ca42cb

The browser build on the 1.11.0 core: bottom gussets and standing pouches, a certified bound
for shipping_cost and lowest_landed_cost, and one money ceiling.

Added

  • bottom_gusset_depth and orientation: "standing" on a gusseted_bag.
  • optimality.lower_bound and the gap under shipping_cost and lowest_landed_cost.
  • examples/checkout.mjs.

Changed

  • A rate_table priced above 9007199254740991 minor units at its top bracket is refused at
    admission.
  • Measures follow the shared grammar, including upper-case unit suffixes. hull_vertices
    holds at most 32 points.
  • effort_budget limits and tag_limits written as 1000.0 are the integers they equal.

Fixed

  • A JSON count of 2^32 truncated to 0 on wasm32 (max_restarts, tag_limits); it now
    saturates.
  • validate_json could panic on a crafted result with mixed-type values.

Packvium 1.10.0

Choose a tag to compare

@github-actions github-actions released this 08 Nov 13:57
bbbfe08

A rebuild on the 1.10.0 Rust core: pallets may overhang their deck, mailers may have gussets, a
hull turns 24 ways, every placement has an id, a request may name its currency, and three more
objectives state a lower bound. units refuses keys it used to ignore.

Added

  • container.pallet_overhang_limit is honoured, where 1.9 refused it: a load may pass the
    deck by the stated length at each end and width at each side. Positions are measured from
    the corner of the overhang zone; a floor placement's support_ratio is the share of its base
    on the deck; the pallet reports achieved_dimensions and is billed at the larger of its
    declared footprint and that size. Beside access_directions, axles, made_to_measure,
    obstacles, a non-zero void_fill_reserve_ratio or an item's stop_index it throws
    UnsupportedFeatureError.
  • Gusseted bags: deformable_boundary.kind: "gusseted_bag" with side_gusset_depth
    admits a load when b + c <= W + G.
  • 24 rotations for a convex_hull item: 18 signed codes such as -L-W+H after the six
    legacy ones, accepted only on a hull.
  • placement_id on every placement, the canonical JSON of
    [container id, x, y, z, item_type, orientation] in ticks; a fixed_placements[] entry may
    quote it, and validate reports placement_id_mismatch and duplicate_placement_id.
  • currency on the request and on rate_table, echoed on the result; a rate table
    without a request currency, or in another one, throws InvalidRequestError, and validate
    reports currency_mismatch. It never changes the answer.
  • Lower bounds for maximum_value, open_dimension_height and maximum_volume, so
    optimality.lower_bound is stated under every objective but the two carrier ones.
  • A made-to-measure box may keep a void_fill_reserve_ratio.

Changed

  • units refuses every key but length: InvalidRequestError with reason not_allowed
    at /units/<key>. Write the unit on each weight instead of units.weight.
  • Every container is numbered per type on the grid lattice and block loader too:
    pair#1, large#1 where 1.9 could say pair#2 or large#10.
  • An unknown deformable_boundary.kind is refused with both kinds listed.
  • Built with wasm-bindgen 0.2.130.

Fixed

  • An explicit rotation list emptied by keep_upright is refused at allowed_rotations,
    with the same named request error the independent validator checks.
  • Stocking cut boxes indexes artifact lookups once and reports malformed consumed
    machine fields as structured invalid_revision errors.

Packvium 1.9.0

Choose a tag to compare

@github-actions github-actions released this 01 Nov 19:19
f58d145

A rebuild on the 1.9.0 Rust core: the centre of gravity is checked, and answers agree with the
other engines where 1.8 found them apart.

Changed

  • Under a clearance a compressible item bears its load on its own footprint, so its crush
    check is stricter and validate measures its own compressed volume.
  • Breaking for weights past 2^53 - 1 ticks: a weight's ticks, and a shipping_cost
    score position, are a BigInt past it, so JSON.stringify refuses such a result; the new
    stringifyExact and parseExact carry it through JSON exactly. Below it nothing changes.
  • A weight is at most 2^63 - 1 ticks, and so is every item's weight times its quantity plus
    the heaviest tare
    : past it, invalid_request / above_maximum; a weight written as a JSON
    number past 2^53 - 1 is invalid_value and must be a string.
  • The centre of gravity is checked under a minimum_support_ratio above 0: a placement
    covering at most half its base with the centroid outside the contact hull is refused.
    A request without a ratio packs as before.
  • Agrees with the other engines where 1.8 did not: nesting under a clearance shares the
    items' own overlap and a deep nesting column nests in pairs; a length past 2^53 - 1 ticks or
    a box past 10^30 cubic ticks is invalid_request / above_maximum; a side that reads as zero
    ticks is invalid_value / must be positive; an obstacle box outside its container is
    invalid_value / lies outside inner_dimensions, each at its own pointer.
  • validate checks the centroid (centre_of_gravity_unsupported) and the whole stack's load
    (top_load_exceeded)
    , an item on several bearers shared by contact area. It no longer
    holds that item's whole weight against every bearer, so it accepts some results 1.8 rejected
    and names the overloaded bearer.
  • A plan beam wider than 1 compares every container type, whatever the node limit.
  • Accepts null obstacle coordinates as zero, including additional boxes,
    consistently with request admission.

Packvium 1.8.0

Choose a tag to compare

@github-actions github-actions released this 26 Oct 20:15
8cefa62

A rebuild on the 1.8.0 Rust core: results say how far they can be from the best possible
answer, validate checks that claim, and a mistyped flag is refused.

Added

  • optimality.lower_bound and the gap under the default and lowest_cost objectives;
    validate checks them.

Changed

  • Only attaining the bound sets optimal, on a complete result, and an effort budget
    names a stop: a run that ends on exactly its budget is complete.
  • A non-boolean keep_upright, stackable, must_be_on_floor or
    require_placement_coordinates throws InvalidRequestError
    (wrong_type); it was read
    as the field's default.
    validate rejects such a request with MalformedResult (contract), and reads null as the
    default.

Fixed

  • solvers: ["homogeneous_blocks"] packs under fast and balanced; it placed nothing.
  • validate reads units: null and units.length: null as millimetres, as the engines do,
    and refuses a units that is not an object, or an unknown units.length, as a contract
    MalformedResult naming the field. units.weight is not a field and is ignored: put the unit
    on each weight.

Packvium 1.7.0

Choose a tag to compare

@github-actions github-actions released this 18 Oct 16:15
70125e7

A rebuild on the 1.7.0 Rust core. Breaking: a refused call now throws a typed Error, not a
string. The reference validator joins the package, and quality looks ahead in its block solver.
No request or result field changes.

Added

  • validate(request, result) and MalformedResult. The reference validator, a promise of a
    list of issues (code, detail), empty when the result is valid; MalformedResult for a
    result of the wrong shape. PackviumWasmModule gains an optional validate_json. The
    WebAssembly module grows by about 414 KB (148 KB gzipped) to carry it.
  • InvalidRequestError, FixedPlacementError, UnsupportedFeatureError and
    CommerceInputError
    , exported from both entry points with their types.

Changed

  • Node 18 or later. The WebAssembly module uses reference types (externref), which
    Node 16 cannot instantiate. 1.6.0's module did too, so it never loaded on the Node 16 that
    engines and this README promised; both now say 18, and CI runs Node 18, 20 and 22.
  • A refused call throws an Error, not a string. Breaking for code that tested
    typeof error === 'string' or read the message as the thrown value. A refused request throws
    InvalidRequestError (a RangeError) or FixedPlacementError with code, reason, field
    and detail; a field the engine does not implement throws UnsupportedFeatureError with
    code and fields; a commerce refusal throws CommerceInputError. The message is the
    engine's own sentence, unchanged. The classes are built as @packvium/engine's are:
    new UnsupportedFeatureError(fields) takes the list of fields, not a message.
  • Every schema enum value is refused as not_allowed. A value outside its list in
    allowed_rotations, the output and dimensional-weight units, shape_type,
    ground_contact_rule or configuration.solvers throws InvalidRequestError with reason
    not_allowed at its JSON Pointer. An unknown output unit was copied through; ticks as an
    output unit is now refused
    , as the schema always said.
  • quality looks ahead in the block solver, completing its leading blocks greedily
    and committing the best, so the answer is never worse than the greedy pass. Under a tight
    effort budget the block start can now report truncated / effort_limit.
  • quality does less work for the same answers. Its staged beam refines
    the best greedy order instead of the first two, and extreme points scan the exposed corners
    instead of every combination of placed faces. Measured on the native Rust build, no answer
    changed with either: the first took 44% off quality's CPU on our benchmark, and the second
    cut what was left to 42%.
  • Portfolio starts go to distinct item orders; a stacking scene that took two
    containers now takes one.
  • no_eligible_container is reported proven, and insufficient_support is reported
    (observed) where the support rule is the only blocker.
  • A nesting_height not below the item's height is refused as invalid_value at its
    pointer, and with no output block the result is written in units.length's schema code.

Fixed

  • A rejected init is retried on the next call instead of cached, and the Node loader
    imports a literal path.
  • incompatible_tags is applied item against item, not against container tags.

Packvium 1.6.0

Choose a tag to compare

@github-actions github-actions released this 11 Oct 16:42
9c5414f

A rebuild of the WebAssembly engine on the 1.6.0 Rust core: boxes cut to measure, flat bags,
stacking groups and a volume-first objective in the request, and a fix for small orders with a
convex_hull item.

Added

  • rebalanceWeight(request, result, {maxMoves}), the same call as in @packvium/engine.
  • made_to_measure, deformable_boundary: {kind: "flat_bag"}, stacking_group /
    accepts_stacking_groups and objective: "maximum_volume"
    in the request, and
    achieved_dimensions and made_to_measure in the result.
  • A warning for items resting on nothing when minimum_support_ratio is 0. No answer
    changes.

Changed

  • An unpacked item names the limit that left it out, the same in every engine.
    Where the search used to fall back to no_feasible_placement or search_exhausted, an item a
    fresh container would take but none is left reports container_inventory_exhausted, and one
    that overloads an axle wherever it stands alone reports axle_overloaded; both are
    inferred. Code that matched the old reason for these cases must match the new one.
  • An explicit solvers: ["homogeneous_blocks"] request packs in the profile's start order
    when the block solver declines the scene
    , so the answer no longer depends on the
    order the items are listed in.
  • quality orders its beam by a convex_hull item's own solid, not its box, so
    it no longer assumes a second wedge cannot fit when it can.
  • The container plan counts a convex_hull item by its own solid too, so
    quality no longer ranks a plan as if wedges that share a container each needed their own.
  • fast and balanced add the block solver as one more start and keep its answer only
    when strictly better.

Fixed

  • Small orders with a convex_hull item finish in a handful of search nodes instead of
    spending the whole time limit.
  • max_payload holds in the block and grid solvers. Their capacity cap narrowed weights
    to 32 bits, so a payload limit above about 537 g was read wrong and a block could overfill
    the container.

Packvium 1.5.0

Choose a tag to compare

@github-actions github-actions released this 04 Oct 18:58
1e650dd

A rebuild of the WebAssembly engine on the 1.5.0 Rust core. No API changes. Searches are
faster, and a misspelt configuration key is now refused (see Fixed).

Changed

  • Faster searches, same results. The Rust core's collision index keeps its cells in a flat
    array instead of a tree; natively that made beam searches 41% faster. Every result is
    byte-identical.

Fixed

  • quality with minimum_support_ratio answers instead of failing with
    solution_failed_validation, and a block answer reports the support each item really has
    rather than 1.0 for every item.
  • A misspelt configuration key is refused. A key the request schema does not declare in
    configuration or its effort_budget (profile for solver_profile, top_k for
    alternatives) was silently ignored, so the request ran on defaults. It is now refused with
    reason not_allowed and the key's pointer, for example /configuration/profile. parallel
    is refused too; this build always runs search starts in sequence.
  • An item that fits no orientation no longer spends the exact search's budget; the search
    now finishes instead of reporting effort_limit. Placements are unchanged.
  • An unknown objective or access direction is refused with its pointer (not_allowed),
    and refusal messages match the documentation.

Packvium 1.4.0

Choose a tag to compare

@github-actions github-actions released this 27 Sep 21:04
0955d6e

A rebuild of the WebAssembly engine on the 1.4.0 Rust core. A request the schema never
allowed is now refused instead of packed (see Fixed).

Added

  • fixed_placements in a request: items already loaded keep their place, count toward
    weight, support and top load, and come back marked fixed: true.
  • A malformed request's error names the bad value: its message reads
    invalid_request: /items/0/quantity: must be at least 1, with a reason from a closed set.

Changed

  • The compiled beam search keeps its speed without its memory cost. Results are
    byte-identical.
  • Container ids number each type from 1, as the other engines number them. Only answers
    with more than one container type change, and only their ids.

Fixed

  • Numbers below their floor are refused. A negative item or container quantity was packed,
    and a zero or negative limit was silently replaced by its default.
  • A placement or obstacle far outside its container is refused instead of wrapping around
    and looking inside it.

Plan revisions are not exposed by this package.

Packvium 1.3.0

Choose a tag to compare

@github-actions github-actions released this 21 Sep 17:32
e8f2b6e

A rebuild of the WebAssembly engine on the 1.3.0 Rust core. No API changes; nothing breaks 1.2.0.

Changed

  • The compiled beam search caches its sort keys instead of recomputing them. Results are
    byte-identical.

Operational artifacts are not exposed by this package.

Packvium 1.2.0

Choose a tag to compare

@github-actions github-actions released this 14 Sep 14:07
46c640e

A rebuild of the WebAssembly engine on the 1.2.0 Rust core. No API changes; nothing breaks 1.1.0.

Changed

  • Faster group batching in the compiled solver: two quadratic scans over group members
    became a single pass. Results are byte-identical.
  • The README now lists examples/shapes.mjs (convex-hull and compressible items).

Execution plans are not exposed by this package.