@myparcel-dev/pdk-admin 2.0.1 → 2.2.0

package/src/actions/composables/queries/account/useOrderCapabilitiesQuery.ts

@@ -15,15 +15,18 @@ import {usePdkAdminApi} from '../../../../sdk';
 export type OrderCapabilitiesInput = {
   cc?: string;
   weight?: number;
+  isBusiness?: boolean;
 };
 
 /**
- * Order-scoped capabilities query — fires the shared CapabilitiesAction with ONLY destination
- * and weight, no carrier/packageType/deliveryType filters. Returns one entry per carrier with
- * the union of `packageTypes`, `deliveryTypes`, and `options` valid for the order context.
+ * Order-scoped capabilities query — fires the shared CapabilitiesAction with ONLY destination,
+ * weight and the recipient business flag, no carrier/packageType/deliveryType filters. Returns
+ * one entry per carrier with the union of `packageTypes`, `deliveryTypes`, and `options` valid
+ * for the order context.
  *
- * Drives the carrier / packageType / deliveryType dropdowns. Refetches only on cc / weight
- * changes so option toggles and dropdown picks don't trigger needless network round-trips.
+ * Drives the carrier / packageType / deliveryType dropdowns. Refetches only on cc / weight /
+ * isBusiness changes so option toggles and dropdown picks don't trigger needless network
+ * round-trips.
  *
  * Errors are logged via `globalLogger.error` so we have a breadcrumb for support, but we
  * deliberately don't surface a user-facing toast — an intermittent capabilities failure
@@ -38,7 +41,7 @@ export const useOrderCapabilitiesQuery = (
   return useQuery(
     queryKey,
     async () => {
-      const {cc, weight} = input.value;
+      const {cc, weight, isBusiness} = input.value;
 
       if (!cc) return [];
 
@@ -46,8 +49,8 @@ export const useOrderCapabilitiesQuery = (
       const proxyCapabilities = pdk.proxyCapabilities as unknown as ProxyCapabilitiesCall;
 
       const body: ProxyCapabilitiesBody = {
-        recipient: {countryCode: cc},
-        ...(weight !== undefined ? {physicalProperties: {weight: {value: weight, unit: 'g'}}} : null),
+        recipient: {countryCode: cc, ...(isBusiness === undefined ? null : {isBusiness})},
+        ...(weight === undefined ? null : {physicalProperties: {weight: {value: weight, unit: 'g'}}}),
       };
 
       const response = await proxyCapabilities({body, parameters: {filterSupported: true}});

package/src/actions/composables/queries/account/useShipmentCapabilitiesQuery.spec.ts

@@ -0,0 +1,64 @@
+import {ref} from 'vue';
+import {describe, expect, it, vi} from 'vitest';
+import {useShipmentCapabilitiesQuery} from './useShipmentCapabilitiesQuery';
+
+type RequestBody = {recipient: {countryCode: string; isBusiness?: boolean}};
+
+let capturedBody: RequestBody | undefined;
+
+const proxyCapabilities = vi.fn((options: {body: RequestBody}) => {
+  capturedBody = options.body;
+
+  return Promise.resolve({results: []});
+});
+
+vi.mock('@tanstack/vue-query', () => ({
+  useQuery: (queryKey: unknown, queryFn: () => Promise<unknown>) => ({queryFn}),
+}));
+
+vi.mock('../../../../sdk', () => ({
+  usePdkAdminApi: () => ({proxyCapabilities}),
+}));
+
+vi.mock('../../../../services', () => ({
+  globalLogger: {error: vi.fn(), debug: vi.fn(), warn: vi.fn(), info: vi.fn()},
+}));
+
+type QueryFnHolder = {queryFn: () => Promise<unknown>};
+
+const fullSelection = (isBusiness?: boolean) => ({
+  cc: 'NL',
+  carrier: 'POSTNL',
+  packageType: 'PACKAGE',
+  deliveryType: 'STANDARD',
+  ...(isBusiness === undefined ? null : {isBusiness}),
+});
+
+describe('useShipmentCapabilitiesQuery', () => {
+  it('forwards the business flag on the recipient body', async () => {
+    capturedBody = undefined;
+
+    const query = useShipmentCapabilitiesQuery(ref(fullSelection(true))) as unknown as QueryFnHolder;
+    await query.queryFn();
+
+    expect(capturedBody?.recipient).toEqual({countryCode: 'NL', isBusiness: true});
+  });
+
+  it('sends an explicit consumer flag on the recipient body', async () => {
+    capturedBody = undefined;
+
+    const query = useShipmentCapabilitiesQuery(ref(fullSelection(false))) as unknown as QueryFnHolder;
+    await query.queryFn();
+
+    expect(capturedBody?.recipient).toEqual({countryCode: 'NL', isBusiness: false});
+  });
+
+  it('omits isBusiness when the flag is not provided', async () => {
+    capturedBody = undefined;
+
+    const query = useShipmentCapabilitiesQuery(ref(fullSelection())) as unknown as QueryFnHolder;
+    await query.queryFn();
+
+    expect(capturedBody?.recipient).toEqual({countryCode: 'NL'});
+  });
+});

package/src/actions/composables/queries/account/useShipmentCapabilitiesQuery.ts

@@ -22,6 +22,7 @@ import {usePdkAdminApi} from '../../../../sdk';
 export type CapabilitiesSelection = {
   cc?: string;
   weight?: number;
+  isBusiness?: boolean;
   carrier?: string;
   packageType?: string;
   deliveryType?: string;
@@ -29,10 +30,10 @@ export type CapabilitiesSelection = {
 
 /**
  * Shipment-scoped capabilities query — fires the shared CapabilitiesAction with the FULL
- * selection (carrier + packageType + deliveryType + cc + weight) and returns the matching
- * carrier entry (the one shipment configuration the user has chosen). Drives the option panel
- * and acts as the invalid-combo signal: when `results` is empty, the chosen combination isn't
- * valid for the order context.
+ * selection (carrier + packageType + deliveryType + cc + weight + isBusiness) and returns the
+ * matching carrier entry (the one shipment configuration the user has chosen). Drives the option
+ * panel and acts as the invalid-combo signal: when `results` is empty, the chosen combination
+ * isn't valid for the order context.
  *
  * The selection ref is the only refetch trigger — no window-focus, mount, or reconnect refetches.
  * Server-side option filtering is opted in via the `filterSupported` query parameter so admin sees
@@ -60,7 +61,7 @@ export const useShipmentCapabilitiesQuery = (
   return useQuery(
     queryKey,
     async () => {
-      const {cc, weight, carrier, packageType, deliveryType} = selection.value;
+      const {cc, weight, isBusiness, carrier, packageType, deliveryType} = selection.value;
 
       // The `enabled` gate guarantees these are all present when this runs; TypeScript can't
       // see through the runtime check, so we narrow explicitly here.
@@ -70,10 +71,10 @@ export const useShipmentCapabilitiesQuery = (
       const proxyCapabilities = pdk.proxyCapabilities as unknown as ProxyCapabilitiesCall;
 
       const body: ProxyCapabilitiesBody = {
-        recipient: {countryCode: cc},
+        recipient: {countryCode: cc, ...(isBusiness === undefined ? null : {isBusiness})},
         // PDK orders carry physical-properties weight in grams (see WeightServiceInterface::UNIT_GRAMS),
         // and the SDK's PhysicalPropertiesWeightV2 expects a {value, unit} object — not a primitive.
-        ...(weight !== undefined ? {physicalProperties: {weight: {value: weight, unit: 'g'}}} : null),
+        ...(weight === undefined ? null : {physicalProperties: {weight: {value: weight, unit: 'g'}}}),
         carrier,
         packageType,
         deliveryType,

package/src/forms/shipmentOptions/createShipmentOptionsForm.spec.ts

@@ -27,6 +27,7 @@ vi.mock('@myparcel-dev/vue-form-builder', () => ({
 
 vi.mock('./fields', () => ({
   createDigitalStampRangeField: () => ({name: '__static_digitalStampRange'}),
+  createDimensionFields: () => [{name: '__static_length'}, {name: '__static_width'}, {name: '__static_height'}],
   createLabelAmountField: () => ({name: '__static_labelAmount'}),
   createPackageTypeField: () => ({name: '__static_packageType'}),
 }));

package/src/forms/shipmentOptions/createShipmentOptionsForm.ts

@@ -17,9 +17,24 @@ import {type ShipmentOptionsRefs} from './types';
 import {createShipmentOptionField} from './fields/createShipmentOptionField';
 import {createDeliveryTypeField} from './fields/createDeliveryTypeField';
 import {createCarrierField} from './fields/createCarrierField';
-import {createDigitalStampRangeField, createLabelAmountField, createPackageTypeField} from './fields';
+import {
+  createDigitalStampRangeField,
+  createDimensionFields,
+  createLabelAmountField,
+  createPackageTypeField,
+} from './fields';
 import {fieldFactoryRegistry} from './fieldFactoryRegistry';
-import {FIELD_CARRIER, FIELD_DELIVERY_TYPE, FIELD_LABEL_AMOUNT, FIELD_MANUAL_WEIGHT, FIELD_PACKAGE_TYPE, FIELD_SHIPMENT_OPTIONS_PREFIX} from './field';
+import {
+  FIELD_CARRIER,
+  FIELD_DELIVERY_TYPE,
+  FIELD_HEIGHT,
+  FIELD_LABEL_AMOUNT,
+  FIELD_LENGTH,
+  FIELD_MANUAL_WEIGHT,
+  FIELD_PACKAGE_TYPE,
+  FIELD_SHIPMENT_OPTIONS_PREFIX,
+  FIELD_WIDTH,
+} from './field';
 
 export const createShipmentOptionsForm = (orders?: OneOrMore<Plugin.ModelPdkOrder>): FormInstance => {
   const ordersArray = toArray(orders ?? []).map(toRaw);
@@ -107,6 +122,9 @@ const buildDynamicRefs = (
   refs[FIELD_PACKAGE_TYPE] = get(order, FIELD_PACKAGE_TYPE);
   refs[FIELD_DELIVERY_TYPE] = get(order, FIELD_DELIVERY_TYPE);
   refs[FIELD_MANUAL_WEIGHT] = get(order, FIELD_MANUAL_WEIGHT);
+  refs[FIELD_LENGTH] = get(order, FIELD_LENGTH);
+  refs[FIELD_WIDTH] = get(order, FIELD_WIDTH);
+  refs[FIELD_HEIGHT] = get(order, FIELD_HEIGHT);
 
   // Dynamic shipment option refs from carrier options
   for (const key of optionKeys) {
@@ -129,6 +147,7 @@ const createShipmentOptionsFields = (
     createDeliveryTypeField(refs),
     createLabelAmountField(refs),
     createDigitalStampRangeField(refs, order),
+    ...createDimensionFields(refs),
   ];
 
   // Dynamic shipment option fields — driven by carrier.options

package/src/forms/shipmentOptions/field.ts

@@ -16,6 +16,12 @@ export const DELIVERY_TYPE = 'deliveryType';
 
 export const MANUAL_WEIGHT = 'manualWeight';
 
+export const LENGTH = 'length';
+
+export const WIDTH = 'width';
+
+export const HEIGHT = 'height';
+
 export const PROP_OPTIONS = 'options';
 
 export const KEY_DESCRIPTION = 'description';
@@ -32,4 +38,10 @@ export const FIELD_DELIVERY_TYPE: FieldName = `${DELIVERY_OPTIONS_PREFIX}.${DELI
 
 export const FIELD_MANUAL_WEIGHT: FieldName = `${PHYSICAL_PROPERTIES_PREFIX}.${MANUAL_WEIGHT}`;
 
+export const FIELD_LENGTH: FieldName = `${PHYSICAL_PROPERTIES_PREFIX}.${LENGTH}`;
+
+export const FIELD_WIDTH: FieldName = `${PHYSICAL_PROPERTIES_PREFIX}.${WIDTH}`;
+
+export const FIELD_HEIGHT: FieldName = `${PHYSICAL_PROPERTIES_PREFIX}.${HEIGHT}`;
+
 export const FIELD_SHIPMENT_OPTIONS_PREFIX: FieldName = `${DELIVERY_OPTIONS_PREFIX}.${SHIPMENT_OPTIONS}`;

package/src/forms/shipmentOptions/fields/createDimensionFields.spec.ts

@@ -0,0 +1,49 @@
+import {describe, expect, it, vi} from 'vitest';
+import {FIELD_HEIGHT, FIELD_LENGTH, FIELD_WIDTH} from '../field';
+import {createDimensionFields} from './createDimensionFields';
+
+// Full mock (no importOriginal) to avoid the Vue file import chain
+// that triggers "Install @vitejs/plugin-vue" errors.
+vi.mock('../../helpers', () => ({
+  resolveFormComponent: () => 'MockNumberInput',
+  defineFormField: (config: Record<string, unknown>) => config,
+}));
+
+describe('createDimensionFields', () => {
+  it('creates a field per dimension, in centimeters', () => {
+    const fields = createDimensionFields({});
+
+    expect(fields.map((field) => field.name)).toEqual([FIELD_LENGTH, FIELD_WIDTH, FIELD_HEIGHT]);
+    expect(fields.map((field) => field.label)).toEqual(['length_in_cm', 'width_in_cm', 'height_in_cm']);
+  });
+
+  /**
+   * Only `attributes` is bound to the rendered input; `props` is merely readable from `element.props`
+   * by components that opt in, and no number input does. A `min` on `props` would silently do nothing,
+   * so assert the channel and not just the value.
+   */
+  it('puts min on attributes so it reaches the input', () => {
+    const fields = createDimensionFields({});
+
+    fields.forEach((field) => {
+      expect(field.attributes).toEqual({min: 0});
+      expect(field.props?.min).toBeUndefined();
+    });
+  });
+
+  it('leaves untouched fields undefined rather than defaulting them to 0', () => {
+    const fields = createDimensionFields({});
+
+    expect(fields.map((field) => field.ref?.value)).toEqual([undefined, undefined, undefined]);
+  });
+
+  it('seeds each field from the order refs when a value was stored', () => {
+    const fields = createDimensionFields({
+      [FIELD_LENGTH]: 40,
+      [FIELD_WIDTH]: 20,
+      [FIELD_HEIGHT]: 30,
+    });
+
+    expect(fields.map((field) => field.ref?.value)).toEqual([40, 20, 30]);
+  });
+});

package/src/forms/shipmentOptions/fields/createDimensionFields.ts

@@ -0,0 +1,32 @@
+import {type InteractiveElementConfiguration} from '@myparcel-dev/vue-form-builder';
+import {type ShipmentOptionsRefs} from '../types';
+import {FIELD_HEIGHT, FIELD_LENGTH, FIELD_WIDTH, type FieldName} from '../field';
+import {defineFormField, resolveFormComponent} from '../../helpers';
+import {AdminComponent} from '../../../data';
+import {createRef} from './createRef';
+
+/**
+ * The parcel dimensions the merchant may fill in manually, in centimeters — the same unit the API
+ * expects and the backoffice shows, so nothing is converted.
+ *
+ * `min` is a UX guard, not validation
+ *
+ * The refs have no fallback on purpose. An untouched field must stay undefined so it is left out of
+ * the request entirely; defaulting to 0 would send a dimension the merchant never entered.
+ */
+const DIMENSION_FIELDS: [name: FieldName, label: string][] = [
+  [FIELD_LENGTH, 'length_in_cm'],
+  [FIELD_WIDTH, 'width_in_cm'],
+  [FIELD_HEIGHT, 'height_in_cm'],
+];
+
+export const createDimensionFields = (refs: ShipmentOptionsRefs): InteractiveElementConfiguration[] =>
+  DIMENSION_FIELDS.map(([name, label]) =>
+    defineFormField({
+      name,
+      label,
+      ref: createRef<number | undefined>(refs, name),
+      component: resolveFormComponent(AdminComponent.NumberInput),
+      attributes: {min: 0},
+    }),
+  );

package/src/forms/shipmentOptions/fields/index.ts

@@ -1,4 +1,5 @@
 export * from './createDigitalStampRangeField';
+export * from './createDimensionFields';
 export * from './createInsuranceField';
 export * from './createLabelAmountField';
 export * from './createPackageTypeField';

package/src/forms/shipmentOptions/useCapabilitiesWatcher.spec.ts

@@ -1,5 +1,5 @@
-import {describe, expect, it} from 'vitest';
 import {ref} from 'vue';
+import {describe, expect, it} from 'vitest';
 import {useCapabilitiesWatcher, type FormInput, type OrderInput} from './useCapabilitiesWatcher';
 
 describe('useCapabilitiesWatcher', () => {

package/src/forms/shipmentOptions/useCapabilitiesWatcher.ts

@@ -4,7 +4,8 @@ import {type CapabilitiesSelection} from '../../actions/composables/queries/acco
 
 const DEBOUNCE_MS = 100;
 
-export type OrderInput = {cc?: string; weight?: number};
+export type OrderInput = {cc?: string; weight?: number; isBusiness?: boolean};
+
 export type FormInput = {carrier?: string; packageType?: string; deliveryType?: string};
 
 /**

package/src/forms/shipmentOptions/wireProxyCapabilities.spec.ts

@@ -1,5 +1,5 @@
-import {describe, expect, it, vi, beforeEach} from 'vitest';
 import {effectScope, nextTick, ref} from 'vue';
+import {describe, expect, it, vi, beforeEach} from 'vitest';
 import {BackendEndpoint, TriState} from '@myparcel-dev/pdk-common';
 import {FIELD_CARRIER, FIELD_DELIVERY_TYPE, FIELD_MANUAL_WEIGHT, FIELD_PACKAGE_TYPE} from './field';
 
@@ -35,12 +35,12 @@ const buildForm = (initial: Record<string, unknown>) => {
   });
 
   return {
-    getValue: <T,>(name: string): T => fields.get(name)?.ref.value as T,
+    getValue: <T>(name: string): T => fields.get(name)?.ref.value as T,
     setExternally: (name: string, value: unknown) => {
       const field = fields.get(name);
 
       if (field) {
-        (field.ref as ReturnType<typeof ref>).value = value;
+        field.ref.value = value;
       } else {
         fields.set(name, {ref: ref(value)});
       }
@@ -55,12 +55,14 @@ beforeEach(() => {
   useShipmentCapabilitiesQueryMock.mockClear();
 });
 
-const orderShape = (cc = 'NL', initialWeight = 1500) =>
+// `isBusiness` is omitted from the shipping address unless explicitly passed — production
+// orders may not carry the flag at all, so the flag-absent shape is the representative default.
+const orderShape = (cc = 'NL', initialWeight = 1500, isBusiness: boolean | undefined = undefined) =>
   ({
     externalIdentifier: 'order-1',
-    shippingAddress: {cc},
+    shippingAddress: {cc, ...(isBusiness === undefined ? null : {isBusiness})},
     physicalProperties: {initialWeight},
-  }) as never;
+  } as never);
 
 describe('wireProxyCapabilities', () => {
   it('treats TriState.Inherit (-1) as "no manual override" and falls back to initialWeight', async () => {
@@ -105,7 +107,9 @@ describe('wireProxyCapabilities', () => {
     const orderInputRef = useOrderCapabilitiesQueryMock.mock.calls[0][0] as {value: {weight?: number}};
 
     // Wait for the debounce (refDebounced default 100ms in this codebase).
-    await new Promise((resolve) => setTimeout(resolve, 150));
+    await new Promise((resolve) => {
+      setTimeout(resolve, 150);
+    });
     await nextTick();
 
     expect(orderInputRef.value.weight).toBe(4200);
@@ -113,6 +117,54 @@ describe('wireProxyCapabilities', () => {
     scope.stop();
   });
 
+  it('forwards the recipient business flag from the order shipping address to both queries', async () => {
+    const form = buildForm({
+      [FIELD_CARRIER]: 'POSTNL',
+      [FIELD_PACKAGE_TYPE]: 'PACKAGE',
+      [FIELD_DELIVERY_TYPE]: 'STANDARD',
+      [FIELD_MANUAL_WEIGHT]: TriState.Inherit,
+    });
+
+    const scope = effectScope();
+    const {wireProxyCapabilities} = await import('./wireProxyCapabilities');
+
+    scope.run(() => {
+      wireProxyCapabilities(form as never, orderShape('NL', 1500, true));
+    });
+
+    const orderInputRef = useOrderCapabilitiesQueryMock.mock.calls[0][0] as {value: {isBusiness?: boolean}};
+    const selectionRef = useShipmentCapabilitiesQueryMock.mock.calls[0][0] as {value: {isBusiness?: boolean}};
+
+    expect(orderInputRef.value.isBusiness).toBe(true);
+    expect(selectionRef.value.isBusiness).toBe(true);
+
+    scope.stop();
+  });
+
+  it('leaves isBusiness undefined for both queries when the order has no flag', async () => {
+    const form = buildForm({
+      [FIELD_CARRIER]: 'POSTNL',
+      [FIELD_PACKAGE_TYPE]: 'PACKAGE',
+      [FIELD_DELIVERY_TYPE]: 'STANDARD',
+      [FIELD_MANUAL_WEIGHT]: TriState.Inherit,
+    });
+
+    const scope = effectScope();
+    const {wireProxyCapabilities} = await import('./wireProxyCapabilities');
+
+    scope.run(() => {
+      wireProxyCapabilities(form as never, orderShape());
+    });
+
+    const orderInputRef = useOrderCapabilitiesQueryMock.mock.calls[0][0] as {value: {isBusiness?: boolean}};
+    const selectionRef = useShipmentCapabilitiesQueryMock.mock.calls[0][0] as {value: {isBusiness?: boolean}};
+
+    expect(orderInputRef.value.isBusiness).toBeUndefined();
+    expect(selectionRef.value.isBusiness).toBeUndefined();
+
+    scope.stop();
+  });
+
   it('skips wiring and returns undefined when the order has no externalIdentifier (bulk path)', async () => {
     const form = buildForm({});
 

package/src/forms/shipmentOptions/wireProxyCapabilities.ts

@@ -1,8 +1,8 @@
 import {computed, onScopeDispose, type Ref} from 'vue';
 import {type FormInstance} from '@myparcel-dev/vue-form-builder';
 import {BackendEndpoint, type Plugin} from '@myparcel-dev/pdk-common';
-import {globalLogger} from '../../services';
 import {useQueryStore} from '../../stores';
+import {globalLogger} from '../../services';
 import {
   useShipmentCapabilitiesQuery,
   type CapabilitiesSelection,
@@ -15,15 +15,38 @@ import {useCapabilitiesWatcher, type FormInput, type OrderInput} from './useCapa
 import {FIELD_CARRIER, FIELD_DELIVERY_TYPE, FIELD_MANUAL_WEIGHT, FIELD_PACKAGE_TYPE} from './field';
 
 /**
- * Wire BOTH capabilities queries — order-scoped (cc + weight) and shipment-scoped (full
- * selection) — into the shipment-options form for a single order, register them in the query
- * store under composite-string modifiers (`${orderId}.order` and `${orderId}.shipment`), and
- * tear them down when the form's scope disposes (modal close).
+ * Resolve the order-scoped capabilities input from the form + order.
+ *
+ * Read weight through `form.getValue()` (which goes through `q(field.ref)` / `toValue`) rather
+ * than `form.values` so reactive deps are tracked when called inside a computed. Manual weight from
+ * `FIELD_MANUAL_WEIGHT` wins when set — it carries `TriState.Inherit` (-1) when unset, and only a
+ * positive number is a real override; otherwise fall back to the order's initial weight.
+ *
+ * `isBusiness` is the PDK-derived recipient flag (from the company name), forwarded as-is — no
+ * company or other PII is handled here.
+ */
+const resolveOrderInput = (form: FormInstance, order: Plugin.ModelContextOrderDataContext): OrderInput => {
+  const manualWeightRaw = form.getValue(FIELD_MANUAL_WEIGHT);
+  const manualWeight = typeof manualWeightRaw === 'number' && manualWeightRaw > 0 ? manualWeightRaw : undefined;
+
+  return {
+    cc: order.shippingAddress?.cc,
+    weight: manualWeight ?? order.physicalProperties?.initialWeight,
+    isBusiness: order.shippingAddress?.isBusiness,
+  };
+};
+
+/**
+ * Wire BOTH capabilities queries — order-scoped (cc + weight + isBusiness) and shipment-scoped
+ * (full selection) — into the shipment-options form for a single order, register them in the
+ * query store under composite-string modifiers (`${orderId}.order` and `${orderId}.shipment`),
+ * and tear them down when the form's scope disposes (modal close).
  *
  * The two queries serve different concerns:
  *
  * - **Order query** drives the carrier / packageType / deliveryType dropdowns from each
- *   carrier's flat union arrays. Refetches only when destination or weight change.
+ *   carrier's flat union arrays. Refetches only when destination, weight or the recipient
+ *   business flag change.
  * - **Shipment query** drives per-option metadata (`isRequired`, `requires`, `excludes`,
  *   `insuredAmount`) for the chosen combination. Refetches when any axis of the selection
  *   changes; the empty-result case is the invalid-combo signal consumed by
@@ -51,20 +74,7 @@ export const wireProxyCapabilities = (
   const orderModifier = `${orderId}.order`;
   const shipmentModifier = `${orderId}.shipment`;
 
-  // Use `form.getValue(name)` (which goes through `q(field.ref)` / `toValue` internally) rather
-  // than `form.values[name]` so reactive deps are tracked correctly inside computed/watchers.
-  const orderInput = computed<OrderInput>(() => {
-    // FIELD_MANUAL_WEIGHT carries `TriState.Inherit` (-1) when the user hasn't entered a manual
-    // override; only positive numbers represent an actual weight. Treat anything else as "unset"
-    // and fall back to the order's initial weight.
-    const manualWeightRaw = form.getValue(FIELD_MANUAL_WEIGHT);
-    const manualWeight = typeof manualWeightRaw === 'number' && manualWeightRaw > 0 ? manualWeightRaw : undefined;
-
-    return {
-      cc: order.shippingAddress?.cc,
-      weight: manualWeight ?? order.physicalProperties?.initialWeight,
-    };
-  });
+  const orderInput = computed<OrderInput>(() => resolveOrderInput(form, order));
 
   const formInput = computed<FormInput>(() => ({
     carrier: form.getValue<string | undefined>(FIELD_CARRIER),
@@ -77,6 +87,7 @@ export const wireProxyCapabilities = (
   const orderInputForQuery = computed<OrderCapabilitiesInput>(() => ({
     cc: selection.value.cc,
     weight: selection.value.weight,
+    isBusiness: selection.value.isBusiness,
   }));
 
   const orderQuery = useOrderCapabilitiesQuery(orderInputForQuery);

package/src/types/sdk.types.ts

@@ -209,7 +209,7 @@ interface ProxyCapabilitiesDefinition extends PdkEndpointDefinition {
    * SDK's `PhysicalPropertiesWeightV2` model defines it on the wire.
    */
   body: {
-    recipient: {countryCode: string};
+    recipient: {countryCode: string; isBusiness?: boolean};
     physicalProperties?: {
       weight?: {value: number; unit: 'g' | 'kg'};
     };