ARCNM

Make a what-if stick: write moved factors into the calculation's costing environment the way the app's 'apply to this environment' dialog does. Read the factors with arcnm_cost_factors and try them with arcnm_preview_cost first. By default (apply=false) this PLANS only — it returns, per factor, the exact REST write it would make (endpoint, today's value, the new value) and refuses by name what it will not write — and changes nothing. Call again with apply=true to perform the writes. Rates (labour, overheads) and economics scalars are set; tuning factors are set per process; the material price is set for the calculation's grade; a base-seconds knob (setup base, programming base, an allowance) is TAUGHT — the what-if's before and after seconds become one calibration observation, which moves the environment's learned factor rather than pinning a value. A machine's own hourly rate, cutting data, the lot size, a scrap price and the tuning panel's own settings (the remnant value factor, the inspection times) are refused with the endpoint or tool that holds them. Every write changes the environment: the next calculation in it is re-priced and billed as usual. recalculate=true additionally starts a new calculation of this part on the changed environment (billable) — asked what this calculation was asked, its stock format included — and returns its id and what running it answered (recalculation_status). Needs parts:write.

Check this organization's remaining calculation quota for the current billing window BEFORE committing a run — how many calculations are included, used, and remaining, whether the plan hard-caps (over-quota parks as 'blocked') or bills overage, how overage settles ('wallet' = prepaid, so the balance is the ceiling — 'wallet_funded_calculations' is how many more fit), how much of the monthly overage cap is left, and whether billing is suspended. Use it to top up, upgrade or raise the cap up front instead of discovering the wall when a calc parks. Read-only.

Compare two calculations and explain the offer-price delta (the price each calculation headlines), with the unit-cost delta before surcharges beside it. Compares like with like: flags when the two used different lot sizes or costing environments, and states no delta across currencies. For the same part(s) across several rate environments use arcnm_compare_environments instead. Read-only — does not re-price.

Compare the same part(s) priced across several rate environments — the parts × environments matrix of a multi-environment run. Pass the batch_id returned by a multi-environment quote/batch, OR an explicit list of calculation_ids (e.g. runs of the same part from different days). Returns, per part, the offer price (and the unit cost before surcharges) in every environment and the environment with the lowest offer price (ties included), and per environment the win count, basket total and median delta vs the baseline — all server-computed, identical to what the API and UI report. Read-only — does not re-price. To START a multi-environment run, create a batch with costing_environment_ids first. Up to 200 calculation_ids, and the pivoted grid may not exceed 500 cells (parts x environments) — compare fewer runs, or fewer distinct environments, if it does.

Get one calculation as a single rough-to-detailed hierarchy — headline → cost category → operation → feature, with time and cost side by side — so you can stop at the depth you need. The cost tier is the itemised cost sheet: every category with the tiers beneath it (per machine, per clamping, per work element), each line carrying its time, its rate and the factors that would move it — the same tree the app renders, node for node. Pass a persona to slice it: 'procurement' (headline + band, shareable without a CAD seat), 'workprep' (the routing / operations tier as a work plan), 'operations' (routing + machines for shop balancing), 'design' (the cost sheet + per-feature drivers for DfM), or 'full' (every tier). Every persona also gets material_stock: the stock the part is bought as (format, size, parts per stock), its mass balance, and the material line's purchase and scrap and remnant credits. Pass quantity (1 to 1,000,000,000) to read the headline, the times and the cost tier at another lot size, with quantity and basis stating which lot and where the figures come from: a quantity on the calculation's lot-size curve is served as recorded, any other is restated from the calculation's own closed form; a calculation that records no closed form (or one that cannot be read) refuses the quantity by name. The headline at any lot is the manufacturing cost per part, the same figure the ordered lot's unit_cost means. The operations, feature and material_stock tiers describe the lot the calculation was priced for. Read-only.

Rank the top cost drivers of a calculation (largest first) so you can target a redesign or re-quote — each with its cost, its share of the unit cost, and why it is costly. This is the FEATURE axis: which pocket, hole or slot the money goes into, the view you act on to change the PART. For the CATEGORY axis — which cost line (material, setup, machine, labour, …) it sits in, and the per-machine, per-clamping, per-work-element tiers beneath it — use arcnm_cost_breakdown, which serves the itemised cost sheet. Neither derives the other: one feature's cost is spread across several cost lines, and one cost line covers many features. Read-only.

List every number a costing environment lets you change, resolved: what each factor is worth here, whether that is your own statement, one inherited from a parent environment, learned from your reported outcomes or the platform's default, the range a what-if may explore, which cost-sheet lines it moves, and the endpoint that saves it. Read this BEFORE proposing a change — a value outside a factor's band is refused, and a factor that drives no line of this part changes nothing. The environment id is on any calculation as costing_environment_id (also returned by arcnm_explain_cost and arcnm_cost_breakdown). Read-only.

Explain what a manufacturing calculation costs and why, as a concise structured summary: headline unit/total/setup cost, the prediction band, the cost breakdown, the machine used, and the top cost drivers. Pass detail='detailed' for more drivers. Read-only.

What nesting the organization's sheet quotes of the last 90 days together on shared sheets would save, and how many nesting runs are used and how many remain in the current window. The figure is a lower bound against each part on its own sheet as its quote priced it — never one quote's price or a layout. Without the Nesting add-on it is floored. Read-only.

Stop a job nest that has not ended — queued, running, or kept as a draft. By default (apply=false) this only reads the job nest and says whether it can be cancelled and what cancelling does. apply=true (needs parts:write) cancels it: the materials and thicknesses already nested keep their result, the others are cancelled, and every remnant it holds goes back to stock. Cancelled before any material and thickness is nested, it gives its run back to this month's allowance; once one is nested, it counts as a run. A draft is discarded. A job nest that has ended (solved, failed or cancelled) is not cancelled again.

Nest a backlog of sheet-metal parts together — several orders, materials and thicknesses at once — to learn what each order and each part costs on the sheets they share. Name the calculations (items: calculation_id, and optionally quantity — the lot size when omitted — order_ref, due, priority), OR a batch_id, OR a folder_id; each calculation must be of a sheet-metal part priced in environment_id. By default (apply=false) this PLANS only: it returns what the job nest would take — the lines and copies of each material and thickness, the remnant pieces of it in stock, and what a batch or folder leaves out and why — and starts nothing. Call again with apply=true to start it (needs parts:write); it runs in the background: poll arcnm_nest_run_status, then read arcnm_nest_run_result. When this month's runs are used, apply=true keeps the job nest as a draft instead — stored, not queued, spending no run — and arcnm_nest_run_start starts it later; the plan says so first (kept_as_draft). A job nest takes every remnant it cuts from out of stock and puts its reusable rests in, so each one started uses stock; the same call within 24 hours answers the job nest it already started. It never changes a calculation's own price.

The cutting files of a job nest's sheets — every solved material and thickness, each distinct layout once with how many identical sheets it stands for. sheet='all' (the default) covers every sheet (the DXF/SVG download link is a zip with plan.json and manifest.csv); sheet=':' one sheet, as the plan names them. format='json' (the default) answers the nest plan inline — every part's contour and holes in millimetres, every sheet with its container, material, thickness, allowances and placements (x, y, rotation, mirror) — and its download link. format='dxf' or 'svg' answers nothing inline: each sheet's download link, to GET with your API key. The DXF is R2010 in millimetres, one block per part and one insert per copy, on the layers SHEET, MARGIN, REMNANT, CUT_OUTER, CUT_INNER and LABEL; exploded=true writes plain closed polylines in place instead of blocks, for a cutting system that reads no block references. Contours are within 0.2 mm of the unfolded flat pattern; arcs are polylines. Read-only.

What a job nest came to: the sheets of each material and thickness with their utilisation; each order's and each line's share of the sheets — what they cost bought, less what the skeleton sells for as scrap and the reusable rests are worth back in stock, in total and per copy (a line's per copy is what a calculation priced on it pays, which is less where the part's own sheet holds it more densely); what a batch or folder left out; and the remnants it used from stock and created. Each line carries its line_id: create a calculation of the part with nest_item_id set to it to price the part's material on its line. Its savings: the sheet bought with each part nested alone against the parts nested together, and what nesting them together saved, in kg and money, per order too — and whether the job nest was released (counts toward the total) or is a simulation (potential). detail='concise' lists the first 50 lines, detail='full' every line. Read-only.

Start a job nest that was kept as a draft — one created with arcnm_nest_run_create while this month's runs were used, which is stored, not queued, and never starts by itself. By default (apply=false) this only reads the job nest and says whether it is a draft and what starting it would nest. apply=true (needs parts:write) queues it: it spends one of this month's runs and is nested at today's stock and prices in the background — poll arcnm_nest_run_status, then read arcnm_nest_run_result. While the month's runs are still used, the start is refused and the job nest stays a draft. Only a draft starts, and only once; the same call within 24 hours answers the start it already made.

How far a job nest has got: its status (queued, running, solved, failed or cancelled), how many of its materials and thicknesses are done, and each one's status, sheets and utilisation so far. Poll it after arcnm_nest_run_create with apply=true; once it is solved, read arcnm_nest_run_result. Read-only.

The organization's total saved by nesting: the released job nests' savings summed — the sheet their lines buy cut from rectangular blanks, with each part nested alone and nested together, what nesting saved against rectangular blanks and its split into each part's true shape and the orders nested together, money per currency and kg — and, apart from the total, the potential of the job nests that ended as simulations (not released). A job nest counts once the shop releases it in the app; nothing here releases one. Read-only.

Get every research-grounded cost-optimization direction for a calculation: lot sizing and setup reduction, tolerance-cost review, material utilization (buy-to-fly), external-process benchmarking, inspection/programming cost shares, volume-bundling elasticity from the part's own cost curve, DFM issues, and the live supplier-quote gap where a quote exists. Each finding is tagged with its lever family, whether the figures are exact engine math or directional, and the industry method it implements — designed for multi-criteria optimization by an agent. Read-only.

Get the total-cost optimal lot size for a calculation — the quantity that minimises production cost PLUS inventory holding (capital tie-up + storage), capped at one year of demand — with the net saving per year of moving there, the Andler/EOQ cross-check, the cost-vs-quantity curve, and at most two solid optimization directions (adjust the lot size / reduce setup time). Read-only.

Answer 'what would this part cost if …' on a calculation that is already priced: name the factors to move, and optionally a different lot size, and read back the whole itemised cost sheet plus the change per cost category. It is FREE — it consumes none of the organization's included calculations — and it WRITES NOTHING: no new calculation, no change to this one, no change to the costing environment. The part is genuinely re-priced through the same engine, so the answer is a price and not an estimate. Use it to search the factor space: read the bands with arcnm_cost_factors, move one factor at a time to learn what each is worth, then combine the ones that pay. Adjustments are checked against each factor's band first, and a request that cannot be answered exactly is refused by name rather than answered approximately. To make a change stick, save it afterwards through the endpoint the factor's edit_path names. Read-only.

Get the ordered process plan (routing) for a calculation: the sequence of operations that make the part — machining (turning, drilling, sawing …) with each step's work center and cycle time, then the post-machining chain (welding, heat treatment, surface finishing, coating) in the order it is performed — plus the plan-level setup, cycle, and total time and the machine(s) it runs on. Use it to generate a work plan, visualise the sequence, or find the slowest step. Post-machining steps carry no cycle time — bought per order — but do report what each is charged per part, which adds up to the subcontract cost line. Setup is amortised over the lot and reported once at the plan level; a machining step reports no cost of its own (machining cost attributes to features — use arcnm_cost_drivers). Read-only.

Rank 2–20 calculations by offer price (the price each calculation headlines, cost-sheet surcharges included), lowest first, and explain the spread — the N-way generalization of arcnm_compare_calculations. Shows each option's premium over the cheapest with time beside cost, flags when they are not like-with-like (different lot size or costing environment; different currencies are not ranked at all), and lists blocked / unpriced calcs last. Use it to pick between several quotes at once; for the same part(s) across rate environments use arcnm_compare_environments. Read-only — does not re-price.

The cutting file of the sheet a calculation's own price laid its part out on — the part alone, as many copies as its price put on one sheet. A calculation that stored no sheet layout, or that is not cut from sheet, has nothing to export. format='json' (the default) answers the nest plan inline — every part's contour and holes in millimetres, every sheet with its container, material, thickness, allowances and placements (x, y, rotation, mirror) — and its download link. format='dxf' or 'svg' answers nothing inline: each sheet's download link, to GET with your API key. The DXF is R2010 in millimetres, one block per part and one insert per copy, on the layers SHEET, MARGIN, REMNANT, CUT_OUTER, CUT_INNER and LABEL; exploded=true writes plain closed polylines in place instead of blocks, for a cutting system that reads no block references. Contours are within 0.2 mm of the unfolded flat pattern; arcs are polylines. Read-only.

Attach one pack file to a component (component_key from the bill of materials), make it the assembly drawing, or discard it. A component whose drawing changes is priced again; the assembly total re-settles when it finishes.

Create + enqueue one calculation per revision in a single request, grouped under a CalculationBatch — the path an agent triggers when a market signal (a material price move) makes a batch re-cost worth running. Each run is metered on success against the org's subscription (v5/v6 quota + flat overage), exactly like a single /run — there is no separate per-call wallet draw. Free orgs over their included quota are rejected up front (HTTP 402).

Selection is explicit (part_revision_ids) for now; richer criteria (by material category, above-should-cost, …) layer on top of this path later.

Pivot one batch into a parts × environments matrix: per-cell costs and times, best environment per part (ties included), deltas vs the cheapest and vs the baseline environment, and per-environment aggregates (wins, median delta, basket total). All figures are computed server-side, so every consumer sees the same comparison. Poll while complete is false — cells fill in as their runs finish.

For an assembly priced across environments, break one row of the comparison matrix down to its components: each unique component of the assembly becomes a row, each environment a column, every cell that component's own calculation in that environment — cost, live status and drill-down id. Components join across environments by their stable prototype key, so 'which part drives the difference between plants' is answerable at a glance. Empty components when the revision is not a decomposed assembly.

Cancel several queued or running calculations at once, together with the component calculations of an assembly. Each id is reported as succeeded or skipped, for example when it had already finished.

Delete several calculations at once, together with the component calculations of an assembly. This cannot be undone. Each id is reported as succeeded or skipped.

Re-enqueue eligible failed/cancelled/timed_out rows.

Each row goes through the same quota-gate + enqueue path as a direct POST /run so subscription semantics and attempt budgets are enforced identically. A row that's already running, succeeded, out of attempt budget, or over a Free org's included quota lands in skipped. A row whose environment can make nothing lands in unquotable, failed immediately rather than enqueued to fail slowly.

Convenience for a whole comparison grid: cancels the batch's queued/running members in one call — the per-id equivalent of /bulk-cancel without a round-trip to collect the ids first. Terminal members are reported skipped, exactly as the id-list route would.

Cancel a queued / running / polling calculation.

Idempotent: a terminal row is returned untouched. The wallet hold is released as part of the transition so a cancelled calc never debits the org's balance.

The same parts × environments matrix as the batch comparison, for any set of your calculation ids — e.g. re-runs of the same parts from different days or batches. A read expressed as POST only because id lists don't fit in a query string; nothing is created or modified. Cells whose configuration diverges from their row's anchor are flagged incomparable_reasons instead of being silently compared.

Create a calculation for a part revision in a costing environment. Does NOT enqueue — call POST /calculations/{id}/run to price it.

One endpoint covers every part. An attached 2D drawing is read automatically — there is nothing to configure.

Creates exactly one calculation: costing_environment_ids with more than one entry is rejected here — fan a comparison out via POST /calculations/batch, /quote or /upload-and-quote.

Saves a set of factor adjustments under a name so the same question can be asked again later. It stores the inputs, not a price: every name is checked against the factor list and every value against its band, and nothing is priced until you preview it.

Hard-delete a calculation row.

A non-terminal row is first cancelled (which releases the wallet hold) so the worker can no longer transition it; the row itself is then removed. Use Cancel if you want the audit trail to persist.

Removes one saved adjustment set. The calculation it varied is untouched.

Read one calculation in full: its status, the part, revision and costing environment it prices, its inputs such as lot size and material, and its costed result.

The precedence-ordered assembly operations with cost + evidence.

Steps that exist but are unpriced are included with their disclosures — never omitted. Empty (pending: true) until the aggregation has run. 404 for a non-assembly calculation.

The assembly's component table, the polling surface while parts price in.

Rows come from the dispatch-time BOM (position, name, quantity, effective lot) overlaid with each component calculation's LIVE status and cost — so the table renders progressively as children complete, without one request per row. 404 for a calculation that is not an assembly.

Introspect this organization's calculation capacity and queue state.

Read-only snapshot for bulk submitters: how many calculations may run in parallel (inflight_cap), the plan's pending bound and how much of it is used, and the organization's own queue. Poll it to pace a bulk submission instead of discovering limits through 429 responses.

Research-grounded cost-optimization directions for one priced calculation: lot sizing, setup reduction, tolerance-cost review, material utilization, external-process benchmarking, plus agent-grade signals (inspection/programming shares, volume-bundling elasticity, DFM issues) and the live supplier-quote gap where a quote exists. Every figure derives from this calculation's own engine results.

The cost breakdown as the tree it was built as: one line per cost category, the tiers beneath it, and the time and rate each one is made of. Pass quantity for any lot size a calculation accepts: a quantity on the calculation's lot-size curve is answered from the figures recorded while pricing, any other from the same closed form the curve was built from — see basis. Omit it for the lot the calculation was priced at. Calculations priced before the sheet existed are answered from the figures they stored — see rebuilt.

This organization's remaining included-calculation quota for the current window, plus its monthly overage budget. Check it before a bulk run so you can upgrade the plan (or raise the overage cap) up front instead of discovering the wall when a calc parks as blocked.

List calculations for the tenant.

Paged newest-first by default with a slim projection — no analytics blob, to keep the list response cheap. Walk the whole collection by following next_cursor (or the Link header) until has_more is false; count is this page's size, never the total.

To reconcile a bulk run against your own records, page with order=asc and a created_after bound: rows come oldest-first, so calculations submitted while you are still walking land after your position instead of shifting rows under it.

Optional part_id narrows the result to a single part. Optional ids turns this into the bulk polling surface: poll one request per sweep, not one per calculation.

The named adjustment sets saved against this calculation. Each one stores the factors it moves and never a price: re-run the preview to see what it costs today, because a rate or a factor changed since it was saved changes the answer without changing the scenario.

Per-component specifiability (§9).

Overridable: material, provided (beigestellt) stock, qty_per, scrap_pct, and purchased (a bought-in standard part priced from its catalogue price — the highest-value override in practice). Extracted geometry and recognised features are NOT overridable here; disagreement goes through the correction/labeling surface.

A quantity/material change re-runs exactly that component and then the roll-up; a purchased flag re-runs the roll-up only. The override is keyed by the component's stable key, so it survives re-upload of the same assembly.

Override the material on an existing calculation.

The new material_grade_id is resolved exactly the same way POST /calculations resolves it on create, so the result is consistent with the create-time logic.

The calculation isn't re-priced here — follow up with POST /run if a re-quote is desired. The explicit two-step flow lets you review the override before paying for another pipeline pass.

Answers 'what would this part cost if …' over a calculation that is already priced: name the factors to move and read back the whole cost sheet plus the change per category. It reuses this calculation's own inputs and produces nothing you keep — no new calculation, no change to this one, no change to your environment — and it consumes none of your included calculations. Adjustments are checked against each factor's band before anything is priced, and a request that cannot be answered exactly is refused by name rather than answered approximately.

Convenience: create + enqueue in one round-trip.

Equivalent to POST / + POST /{id}/run. With costing_environment_ids the part is priced in every requested environment at once (one calculation per environment, grouped under batch_id for comparison).

Enqueue the calculation onto the worker queue — subject to coverage.

Idempotent: a row in a non-terminal state (queued/running/polling) is not re-enqueued; a row in succeeded is returned untouched — a finished result is a record of one run, so re-pricing the part after its inputs changed (inputs_changed_since_run) means creating a new calculation on the same revision and running that; a row in failed/cancelled/timed_out is reset to queued and re-enqueued so the user can retry.

Coverage: before enqueueing, the org's included-calculation quota is checked. A hard-capped org with no included extraction left FAILS FAST: the calc is parked as blocked (never a queued orphan) and the request raises 402 quota_exceeded with the upgrade path (F-2) — except when the dedup cache can serve an identical prior run, which stays free even over quota. A payment-blocked (dunning) org or an over-spend-cap API key still parks with a coverage payload on a 2xx. A blocked row resumes through this same path once unblocked, without spending a retry attempt.

Changes the label and/or the adjustment set of one saved what-if. A new adjustment set is checked against the factor list and every band exactly as on save, and the scenario's cached result is worked out again.

JSON-body twin of /upload-and-quote for clients that can only pass strings (MCP): the CAD file — and optional drawing / RFQ — ride as base64 (or data: URI) strings. Best for small single-part STEP files; base64 inflates ~33% and rides inside the call, so use the presign flow for large assemblies. Same find-or-create-by-part_number idempotency, billing, and enqueue semantics as the multipart route.

The headline customer-facing endpoint — turn a list of ERP actual unit costs into a calibrated environment in one call. Each actual is paired with the most recent successful quote for its part at its lot size in this environment, priced by the current version of the costing model, and the calibration is fitted to the difference; nothing is re-quoted. Parts with no such quote — none at all, or only one priced before the costing model last changed — are returned in unmatched_part_ids so you can quote them and retry. Safe for AI-agent use over MCP and idempotent: the same set of actuals yields the same result.

ERP-native variant of auto-calibrate: accepts the raw columns most ERPs export (part_number, work_order_id, quantity, total_cost) and handles part-number resolution + unit-cost derivation server-side. Idempotent on work_order_id.

Calibrate how this environment chooses a machine, using a list of historical 'the shop actually picked machine X' decisions. Once calibrated, the environment's machine recommendations better match your shop's real choices.

Retire the environment's active calibration without replacing it: quotes priced after this call use the uncalibrated defaults. The run history is kept, so any earlier run can be restored with the revert endpoint. Fails when no calibration is active.

Calibration status for an environment: whether it has been calibrated to your actuals and, for the first-party app, the per-driver adjustments (machine / labour / overhead) with their confidence intervals. Public integrations receive the status only.

Reverse-chronological list of this environment's calibration runs: when each ran, how many observations it used, and whether its result is the currently active calibration. Use it to pick the run to revert to. Read-only; safe for AI agent use.

Read view of an environment's calibration health: whether it is calibrated, when it was last calibrated, and how many submitted observations are waiting to be applied. Designed as the AI agent's discovery endpoint — call this first to decide whether to submit fresh observations or recalibrate.

Resolves the part_number column of an ERP export against the parts you hold and returns how many match. Reads only — it needs no environment and it writes nothing.

Recalibrate this environment for the selected target metric using every observation submitted for it so far, then activate the result. Use after submitting observations. Only an observation whose predicted value comes from the current version of the costing model is fitted: one submitted before the model last changed, or naming a calculation priced before it, is left out and counted in message, and a run with none left is refused. To start from raw ERP actuals without submitting observations first, use the one-click auto-calibrate endpoint instead.

Calibrate how this environment's per-unit cost falls as cumulative production grows, using a sequence of production-lot actuals for one part. Choose the cumulative model (the safer default, observed directly) or the per-unit model. Submit at least three lots.

Calibrates the environment on every now-matching row, exactly as the one-click auto-calibrate endpoint would, and returns the same result shape (mape_before → mape_after). Refused (409) while priced pairs are still running. Metered as one calibration run. Idempotent: a completed import replays its stored result without metering a second run.

Upload historical actuals as rows. Every row is resolved against your part library and bucketed: already priced (free), servable from cache (free), needs a new calculation (billable), or unusable (with the fix named). Only a quote priced by the current version of the costing model counts as already priced; a part quoted only before the model last changed needs a new calculation. NOTHING is priced or spent by this call — the disclosed calculations_required is committed explicitly via POST /calibration/imports/{id}/price. Re-posting the same rows returns the same import until the costing model changes; after that, the same rows start a new import.

Joins every priced row to its calculation and folds terminal outcomes back onto the rows (succeeded → priced, failed → pricing_failed, verbatim reason attached). settled is the green light for POST /calibrate. Rows are capped at 1000 in the response; the counts never are.

Submit a batch of observations (predicted vs. actual outcomes) for an environment so it can be calibrated. Tenant-bound; scope='environment' only. Safe for AI agent use: idempotent on each observation's natural key and rate-limited by the global tenant policy. Recalibrate the environment afterwards to apply the accumulated observations. Take each predicted value from a current quote: an observation is recorded with the version of the costing model current when it is submitted, and once the model changes, recalibration leaves it out until it is submitted again with a predicted value from the new model.

Ranks the missing evidence for an environment: which parts or lot sizes to submit actuals for next, and where the model is capped and needs a configuration review instead of more data. Safe for AI agent use: read-only.

Make an earlier run's calibration the active one again: the current result is retired and the selected run's is restored, exactly as it was fitted — except an adjustment calibration no longer makes (retired_drivers on the calibration report), which is not restored. Nothing is refit and no history is lost — every run stays in the history and can be restored again. Quotes priced after this call use the restored calibration.

Calibrate an environment from caller-supplied (predicted, actual) rows. Each predicted value must come from a current quote for the part: a part this environment priced only before the costing model last changed has none, and a request naming one is refused until the part is priced again. If you only have actuals, use the one-click auto-calibrate endpoint, which pairs each actual with the part's current quote server-side.

Attach an existing DataSource row to a revision.

For a fresh file upload, POST .../datasets/upload creates the DataSource + link in one shot. A client that can only send JSON — every MCP client — uploads with POST /uploads/presign, sends the file the way its method says, calls POST /uploads/confirm and attaches the result here, with the file's role. The upload is checked after confirm answers: until it is confirmed this answers 409 with details.reason upload_pending and Retry-After (also as details.retry_after_s) — ask again then. An upload that was refused, could not be checked or was cancelled answers 409 upload_rejected, upload_failed or upload_cancelled, which waiting does not change.

Detach a file from a part revision. Only the link is removed; the uploaded file itself is not deleted.

List the files attached to a part revision, such as its STEP model and drawings, with each file's name, type, role and whether it is the primary file.

Edit a dataset link.

Currently supports two fields:

• filename: rename the underlying DataSource.

• is_primary: promote/demote within the parent revision. The "exactly one primary" invariant is maintained server-side: when promoting, every other link on the same revision is demoted in the same transaction so concurrent primaries can't co-exist.

Attach one of your subcontractors to this environment.

Attach one of your crib tools to this environment.

Add a machine to a costing environment so calculations in it can plan on it: one of your machines, a machine-library entry, or a new machine defined inline, with optional rate and capability overrides.

Duplicate one of the tenant's OWN environments (env + rates + fleet) into a fresh, non-baseline, uncalibrated copy — "start from this environment, then tune or calibrate the duplicate". Only the tenant's own envs can be cloned (any other id, including a platform preset or another tenant's env, → 404).

Deep-copy a platform region preset (env + rates + fleet) into the tenant.

The clone is immediately runnable and priceable for every discipline. Only a genuine platform preset can be cloned — any other id (including another tenant's env) reads as 404.

Create a costing environment, a named set of machines, tools, rates and overrides that calculations are priced in. By default it starts as a copy of your default environment; source can start it blank (tools only) or empty. Counts against your plan's environment limit.

Delete an environment. ON DELETE CASCADE on the rate + machine- membership tables means the rates + memberships disappear with it; the underlying MachineDefinition rows survive (they're org- scoped, not env-scoped, and may be reused by sibling envs).

Delete one rate from a costing environment: a labour, overhead, material, FX or subcontract rate. This cannot be undone.

Detach a subcontractor (SCD2: the membership closes its window; a same-day attach+detach hard-deletes the zero-length row).

Detach a tool from this environment (SCD2 retire; a same-day attach is hard-deleted). The heal-forward record means a detached tool is never silently re-attached by provisioning.

Remove a machine from a costing environment, so calculations run afterwards no longer plan on it. The machine definition itself is kept.

Set the typed regional economics this environment states itself: energy price, floor-space cost, default material family, the cost-sheet surcharges (material overhead, residual production overhead, administration and selling, profit mark-up) with packaging, freight and duty, the price terms priced in 'im Hundert' (cash discount, sales commission, customer discount), and the inspection / holding scalars. Omit a field to keep it; send null to clear it, which stores nothing on this environment so the value inherits from the parent environment again and ends at the platform default. Takes effect on the next calculation.

Read the environment's calculation-tuning knobs with provenance: stated on this environment, inherited from a parent environment, or the platform default — the order calculations read them in.

Read one costing environment in full: its currency, region, validity dates and the rates, overheads and surcharges that calculations in it are priced with.

Audit the data a price in this environment depends on: unsourced or out-of-range cutting data and overrides, tools priced without a life, unresolvable machines, spindle classes with no power stated, members that source nothing, rate rows in another currency, and — while the environment credits sold scrap — published scrap prices more than 90 days old. Read-only; every finding names the panel that fixes it.

Every number the cost sheet lets you change, resolved for this environment: what it is worth here, where that came from, the range a what-if may explore, which cost lines it moves, and the endpoint that saves it.

Values are read through the same resolvers a calculation uses, so a factor shown here is the factor that was charged.

Integration credentials receive your own statements; the platform's own defaults are shown in the app.

What this environment states differently from the platform defaults, per lever — the honest zero-setup meter. Counts only; every line maps to a Setup panel and, on the default environment, to its restore.

How this environment answers the shop-practice questions — packaging, deburring, and whether sold scrap and reusable remnants (sheet remnants, bar and tube ends) are credited against the material bought. Each answer says where it comes from: stated here, inherited from a parent environment, or the platform default.

List the organization's costing environments, newest first.

The response is a plain array, so the page position travels in the Link (RFC 8288) and X-Next-Cursor / X-Has-More response headers.

Machines wired to this env, ordered by fleet_priority (lower = earlier candidate). The same fleet feeds every pricing run for the environment. at answers "what does the fleet look like on date X" — the same active_as_of window pricing resolves on that date (rates already take ?at); it defaults to today.

The subcontractors THIS environment orders from (active memberships). An external operation priced here that no member offers carries a subcontract_unsourced note on the result — a note, never a veto.

The crib tools THIS environment runs (active memberships). What the engine prices with — an empty list means the environment deliberately runs no crib tool and every handler keeps its own constants. at answers "what does the crib look like on date X" — the same active_as_of window pricing resolves on that date (rates already take ?at); it defaults to today.

The 6 platform region presets a tenant can clone into a runnable env.

Read-only and platform-scoped: only platform rows (org_id IS NULL) are returned (bypass-read inside the service), so no tenant data is exposed.

List all rates for an env, uniformly shaped so the rate editor can render every kind side by side. Optional ?kind= filter.

Benchmark Zuschlagskalkulation rates from primary sources (automotive supplier mark-ups on total manufacturing cost; the usual profit mark-up of German public price law), each with its citation and the equivalent environment economics. Nothing here prices on its own: applying a preset means sending its economics to PATCH /environments/{env_id}/economics, which records the rates as that environment's own statement.

Removes the environment's own price rows for this material, so it prices at the platform figure for its category again. Takes effect immediately.

Your number becomes the price per kilogram this environment calculates with, from valid_from onwards. The price it replaces is closed the same day rather than deleted, so past quotes keep the figure they were costed at.

Restore the platform machine set in the default environment: removed machines are re-attached (new SCD2 rows), switched-off ones switch on, platform classes the environment never had are added. Capability overrides and machine rates are untouched. 409 on any other environment.

Drops every rate this environment states, so it prices at the platform defaults again with honest "platform default" provenance. A scrap price that applied on an earlier day stays on record, ending yesterday, so quotes already made keep it. Your assumptions, tuning and calibration are untouched. Takes effect immediately. Only the default environment can be restored.

Restore the platform subcontractor presets in the default environment: hidden presets return, removed ones re-attach, switched-off ones switch on and are active again. Your own subcontractors and every other environment are untouched. 409 on any other environment.

Restore the platform tool set in the default environment: hidden platform tools return, removed ones are re-attached, switched-off ones switch on. Edited values, custom tools and every other environment are untouched. 409 on any other environment.

The environment's own price for this material and kind of scrap stops applying today. One that started on an earlier day stays on record, so quotes already made keep it; one set today, or for a later day, is withdrawn. Calculations then use the price a parent environment states, or the platform's reference figure.

Every scrap price a calculation in this environment would use today, one row per material, grade and kind of scrap, with whose price it is — this environment's, a parent environment's or the platform's published reference figure — and whether a platform figure is stale. credit_scrap_stated says whether any of them changes a quote yet.

Integration credentials receive your own prices; the platform's reference figures are shown in the app.

Your price per kilogram for the scrap parts of this material leave behind — sheet skeletons and offcuts, chips, or bar ends and cut-offs — from valid_from onwards. Name a grade with grade_id to price it apart from the rest of its category. A price it replaces that started on an earlier day stops the day before rather than being deleted, so quotes already made keep the figure they were costed at; one set earlier the same day is simply replaced.

A scrap price is credited only in an environment that credits sold scrap: the shop-practice question scrap_credit.

Your number becomes the price this environment uses for this operation, from valid_from onwards. Prices you were holding open for the same operation are closed the same day rather than deleted, so quotes you have already sent keep the figure they were costed at.

This one replaces: afterwards there is a single open price for the operation. To put a second subcontractor's quote on file alongside the one you already hold, use POST /environments/{env_id}/rates, which adds a price and closes nothing.

Write env-tier tuning overrides (audited).

setup_factor / programming_factor / cycle_factor write the per-bin setup_efficiency / programming_efficiency / cycle_efficiency resolver overrides for every routable process bin at ENV tier; 1.0, their identity, clears the override. processes writes the same three cells for only the processes it names, applied after the flat fields.

The four REFA allowances (verteilzeit_pct, erholzeit_pct, ruestverteilzeit_pct, ruesterholzeit_pct) write the same per-bin overrides, over every bin that reads them.

The six sheet-nesting settings (edge_margin_mm, skeleton_web_mm, the three remnant thresholds and cut_to_size_increment_mm) each write their one cell of the sheet-nesting settings, which is where a sheet part's purchase reads them, and remnant_value_factor its cell of the material valuation policy, beside the remnant-credit answer that switches it on. The three bar stock settings (bar_length_mm, bar_clamp_remnant_mm and the shortest end that counts as a remnant, bar_remnant_min_l_mm) write theirs, which is where a turned part's bar is bought. Like the allowances, 0 is a statement and reset is the way back.

The four inspection_* fields write the platform-wide inspection constants in the global bin — the cells the cost sheet's Prüfung line lets a reader move. They read back on GET /environments/{env_id}/factors with their provenance and the platform value beside them, which is where every resolved factor is published; this endpoint's own read model stays the tuning knobs.

learning_rate writes the env's Wright rate. Every change lands an audit row.

null means "no statement" on every field of this body, and never a write: a client that serialises its whole model sends nulls for the knobs it is silent about, and that must leave them alone. Clearing a knob, so that it reads a parent environment's statement where one exists and else the platform default, is the named reset list — the allowances need it (0 is a statable allowance, so they have no identity value to send), and the multipliers accept it as the spelled-out equivalent of sending 1.0. The inspection cells are the one exception: an explicit null there clears the override, the contract the cost sheet's save dialog was built against.

Change a costing environment's name, description, region, currency, validity dates or parent environment. Its machines, tools and rates are changed with their own tools.

Enable/disable a subcontractor here without detaching it.

The engine has always gated on this flag — pipeline_context_cache filters is_enabled.is_(True) when it collects the sourced operation kinds — but no route set it, so it could never be anything but the True it defaults to on attach. A shop wanting to stop sourcing one operation from one subcontractor in one environment had to detach and re-attach, discarding the SCD2 history the membership exists to keep. Same shape as the tool sibling above.

Enable/disable a tool here without detaching it.

Change how a machine is used in one costing environment: its priority among machines that can do the same work, whether it is enabled, and its validity dates.

Answer the shop-practice questions (packaging, deburring, scrap credit, remnant credit, and how sheet is cut: grain direction, mirroring, the web by thickness, micro-joints, common-line cutting, the job nest's rotation step). Each answer sets this environment's time allowances, credit policy or cutting practice from a closed set of choices and is recorded in the audit log; a question you leave out keeps its answer. 'standard' removes this environment's own answer: where a parent environment states one, that answer applies and is returned with source 'parent_environment'; otherwise the platform behaviour does.

Adds a rate and leaves every price you already hold open, so you can keep more than one on file — a second subcontractor's quote for the same operation, for instance. Which of them a part is costed at is decided per order.

This one adds. To state the single price this environment should use — closing the price it replaces — use the PUT for the thing itself: .../rates/subcontract/{operation_kind} for bought-in work, .../rates/material/{grade_id} for a material. A scrap price has only its own PUT .../rates/scrap/{material_category}/{scrap_class}.

Create a folder for organising parts, at the top level or inside a parent folder. Folders that share a parent need distinct names.

Delete a folder and its subfolders. The parts inside are not deleted; they are left without a folder.

Rollup scoped to a folder and all of its subfolders.

Fetch a single folder.

Parts carry a folder_id, so a client holding one previously had to list the whole tree to resolve it to a name.