Masterful Machinery Fork

## [0.1.32] - 2025-12-26

### Added
- New item port with configurable per-slot capacity:
  - Ports can be configured to hold more items per slot than the vanilla stack size. This is exposed as a `slotCapacity` on item port models.
  - Example port model (JSON):

    ```json
    {
      "type": "mm:item_port",
      "rows": 3,
      "columns": 9,
      "slotCapacity": 256    //optinal, defaults to 64
    }
    ```

    - This creates an item port with 3 rows × 9 columns where each slot can hold up to 256 items (logical capacity).
    - Internally the handler keeps a separate authoritative count per slot and updates the display stack to the item max stack size; the `slotCapacity` controls the logical capacity per slot used by recipes and routing.

  - If you create ports programmatically (or via data-driven registrations), set the model's `slotCapacity` field to the desired integer.

- NBT-aware recipe inputs and outputs (weak and strong matching):
  - Recipes can now require item NBT on inputs and produce items with NBT on outputs.
  - Two matching modes are supported:
    - `weak`: required NBT is treated as a subset — the item must contain the required keys but may have additional keys.
    - `strong`: required NBT must match exactly (1:1) — no extra keys allowed.

  - JSON recipe examples:

    - Input (weak, JSON-NBT):
      ```json
      {
        "type": "mm:input/consume",
        "ingredient": {
          "type": "mm:item",
          "item": "hostilenetworks:prediction",
          "count": 1,
          "nbt": { "data_model": { "id": "hostilenetworks:the_outer_end/stalker" } },
          "nbt_match": "weak"  //this line is optional since 'weak' is the default
        }
      }
      ```

    - Output (strong, SNBT string shorthand):
      ```json
      {
        "type": "mm:output/simple",
        "ingredient": {
          "type": "mm:item",
          "item": "hostilenetworks:prediction",
          "count": 1,
          "nbt_snbt": "{data_model:{id:\"hostilenetworks:the_outer_end/stalker\"}}",
          "nbt_match": "strong"
        }
      }
      ```

    - Shorthand output (legacy-friendly): the parser also accepts a shorthand form and normalizes it to an `ingredient` object — for example this is allowed and will be interpreted as an `ingredient`:
      ```json
      {
        "type": "mm:output/simple",
        "item": "hostilenetworks:prediction",
        "count": 1,
        "nbt": "{data_model:{id:\"hostilenetworks:the_outer_end/stalker\"}}"
      }
      ```

  - KubeJS examples:

    - Input using KubeJS Item.of (SNBT string) — weak match (default):
      ```js
      MMEvents.createProcesses((event) => {
        event.create('mm:prediction_item1')
          .structureId('mm:fire_attuned_structure')
          .ticks(4)
          .input({
            type: 'mm:input/consume',
            ingredient: Item.of('hostilenetworks:prediction', '{data_model:{id:"hostilenetworks:the_outer_end/stalker"}}')
          })
          .output({
            type: 'mm:output/simple',
            ingredient: {
              type: 'mm:item',
              item: 'hostilenetworks:prediction',
              count: 1,
              nbt_snbt: '{data_model:{id:"hostilenetworks:the_outer_end/stalker"}}'
            }
          });
      });
      ```

    - Input and output with JSON-NBT and `strong` matching:
      ```js
      MMEvents.createProcesses((event) => {
        event.create('mm:prediction_item2')
          .structureId('mm:fire_attuned_structure')
          .ticks(4)
          .input({
            type: 'mm:input/consume',
            ingredient: {
              type: 'mm:item',
              item: 'hostilenetworks:prediction',
              count: 1,
              nbt: { data_model: { id: 'hostilenetworks:the_outer_end/stalker' } },
              nbt_match: 'strong'
            }
          })
          .output({
            type: 'mm:output/simple',
            ingredient: {
              type: 'mm:item',
              item: 'hostilenetworks:prediction',
              count: 1,
              nbt: { data_model: { id: 'hostilenetworks:the_outer_end/stalker' } },
              nbt_match: 'strong'
            }
          });
      });
      ```

  - Notes on formats:
    - `nbt`: accepts JSON-style NBT (object form) or — in shorthand — a SNBT string. The parser will try to parse SNBT strings into NBT CompoundTags when necessary.
    - `nbt_snbt`: explicitly provides SNBT as a string (useful to avoid ambiguity in tooling).
    - `nbt_match`: either `"weak"` or `"strong"` (default is `weak` if omitted).
---