Update mechanic authoring persistence

src/lib/calculations/mechanic.test.ts

@@ -19,6 +19,84 @@ const custom = (
   inputs,
 });
 
+const closeAndPersonalProgram = (
+  resolvedVariantValue: number,
+): MechanicProgram => ({
+  id: 'close-and-personal-engineering',
+  name: 'Close and Personal Engineering',
+  pools: [
+    {
+      key: 'eligible-allies',
+      label: 'Eligible Allies',
+      scope: 'agent',
+      initial: 0,
+      min: 0,
+      max: 20,
+    },
+  ],
+  clauses: [
+    {
+      id: 'sample-eligible-allies',
+      when: 'proximity_snapshot',
+      reducer: {
+        kind: 'derived_scalar',
+        value: {
+          ref: {
+            source: 'event',
+            path: 'values.alliesWithin30MetersWithAgentGrantedBuff',
+          },
+        },
+      },
+      mutations: [
+        {
+          kind: 'derive',
+          pool: 'eligible-allies',
+          value: { ref: { source: 'reducer' } },
+        },
+      ],
+    },
+    {
+      id: 'resolve-engineering',
+      when: 'tick',
+      reducer: { kind: 'none' },
+      mutations: [{ kind: 'none' }],
+      outcomes: [
+        {
+          id: 'engineering',
+          label: 'Engineering',
+          phase: 'on_event',
+          kind: 'attribute_modifier',
+          scope: 'self',
+          basis: 'flat',
+          attributeId: 'engineering',
+          value: {
+            op: 'multiply',
+            left: {
+              op: 'multiply',
+              left: { ref: { source: 'pool', pool: 'eligible-allies' } },
+              right: resolvedVariantValue,
+            },
+            right: {
+              op: 'add',
+              left: 1,
+              right: {
+                op: 'divide',
+                left: {
+                  ref: {
+                    source: 'equipment',
+                    path: 'protocolTalentUpgrades',
+                  },
+                },
+                right: 5,
+              },
+            },
+          },
+        },
+      ],
+    },
+  ],
+});
+
 describe('deterministic mechanic probabilities and assigned abilities', () => {
   it('rolls outcome probability independently with a reproducible seed and preserves a refreshed window', () => {
     const program: MechanicProgram = {
@@ -321,6 +399,23 @@ describe('structured mechanic runtime', () => {
     });
   });
 
+  it('advertises the optional non-negative integer proximity count without making snapshots strict', () => {
+    const definition = MECHANIC_EVENT_REGISTRY.proximity_snapshot;
+    const countField = definition.fields?.find(
+      ({ path }) => path === 'values.alliesWithin30MetersWithAgentGrantedBuff',
+    );
+
+    expect(definition.strictFields).not.toBe(true);
+    expect(countField).toEqual({
+      path: 'values.alliesWithin30MetersWithAgentGrantedBuff',
+      label: 'Allies within 30 meters with an Agent-granted buff',
+      type: 'number',
+      minimum: 0,
+      integer: true,
+    });
+    expect(countField?.required).not.toBe(true);
+  });
+
   it('advertises imported support and equipment-use trigger events', () => {
     expect(MECHANIC_EVENT_REGISTRY.ally_downed).toMatchObject({
       key: 'ally_downed',
@@ -1306,6 +1401,7 @@ describe('structured mechanic runtime', () => {
       ],
       custom(),
     );
+    expect(result.status).toBe('OK');
     expect(result.finalState[0].value).toBe(2);
     const maximum = evaluateMechanicProgram(program, [], {
       mode: 'maximum',
@@ -1314,6 +1410,81 @@ describe('structured mechanic runtime', () => {
     expect(maximum.finalState[0].value).toBe(3);
   });
 
+  it.each([
+    { count: 0, upgrades: 0, multiplier: 0 },
+    { count: 3, upgrades: 0, multiplier: 3 },
+    { count: 3, upgrades: 5, multiplier: 6 },
+  ])(
+    'resolves Close-and-Personal-style Engineering for count $count and $upgrades OS upgrades',
+    ({ count, upgrades, multiplier }) => {
+      const resolvedVariantValue = 7.25;
+      const result = evaluateMechanicProgram(
+        closeAndPersonalProgram(resolvedVariantValue),
+        [
+          {
+            kind: 'proximity_snapshot',
+            at: 0,
+            values: {
+              alliesWithin30MetersWithAgentGrantedBuff: count,
+            },
+          },
+          { kind: 'tick', at: 1 },
+        ],
+        custom(),
+        undefined,
+        { protocolTalentUpgrades: upgrades },
+      );
+
+      expect(result.status).toBe('OK');
+      expect(result.finalState).toContainEqual(
+        expect.objectContaining({ pool: 'eligible-allies', value: count }),
+      );
+      expect(
+        result.outcomes.find(({ outcomeId }) => outcomeId === 'engineering'),
+      ).toMatchObject({
+        value: resolvedVariantValue * multiplier,
+        resolvedValue: resolvedVariantValue * multiplier,
+      });
+    },
+  );
+
+  it.each([
+    {
+      count: '2',
+      error:
+        'Allies within 30 meters with an Agent-granted buff must be a number.',
+    },
+    {
+      count: -1,
+      error:
+        'Allies within 30 meters with an Agent-granted buff must be 0 or greater.',
+    },
+    {
+      count: 1.5,
+      error:
+        'Allies within 30 meters with an Agent-granted buff must be an integer.',
+    },
+  ])('rejects invalid proximity ally count $count', ({ count, error }) => {
+    const result = evaluateMechanicProgram(
+      closeAndPersonalProgram(7.25),
+      [
+        {
+          kind: 'proximity_snapshot',
+          at: 0,
+          values: {
+            alliesWithin30MetersWithAgentGrantedBuff: count,
+          },
+        },
+      ],
+      custom(),
+      undefined,
+      { protocolTalentUpgrades: 0 },
+    );
+
+    expect(result.status).toBe('INVALID');
+    expect(result.errors).toContain(`Event 1 (Proximity snapshot) ${error}`);
+  });
+
   it('shares one movement charge pool across generation and consumption clauses', () => {
     const program: MechanicProgram = {
       id: 'mobile-charge',